<?xml version="1.0"?>
<doc>
    <assembly>
        <name>Remotion.Mixins</name>
    </assembly>
    <members>
        <member name="T:Remotion.Mixins.AcceptsAlphabeticOrderingAttribute">
            <summary>
            Indicates that an ordinal name comparison can be used to determine the order between two mixins when these override the same methods
            on a target object. Only use this if you don't care about the actual mixin order.
            </summary>
            <remarks>
            <para>
            Ordering between mixins is important when two mixins override the same methods on a target object, because without a defined ordering,
            it wouldn't be deterministic which of the overrides would be executed first. Usually, orderings between mixins are expressed via dependencies.
            Either implicitly, because the mixin has a base call dependency (second type argument of the <see cref="T:Remotion.Mixins.Mixin`2"/> base class) to 
            an interface implemented by another mixin, or explicitly via  <see cref="P:Remotion.Mixins.MixinRelationshipAttribute.AdditionalDependencies"/>.
            </para>
            <para>
            In some situations, however, a mixin cannot and does not need to specify a specific ordering simply because any override call order would
            be sufficient for its purpose. Such a mixin can opt into alphabetic ordering by having this attribute applied to it. Alphabetic ordering is
            only applied after all implicit or explicit dependencies have been analyzed. It is also ruled out if two or more of the mixins involved
            do not accept alphabetic ordering.
            </para>
            </remarks>
        </member>
        <member name="T:Remotion.Mixins.BindToConstraintsAttribute">
            <summary>
            Indicates that a generic parameter of a mixin should be bound to a type inferred from the type parameter's generic constraints 
            (unless the generic parameter type is explicitly specified when the mixin is configured).
            </summary>
            <remarks>
            <para>
            Apply this attribute to a generic parameter of a generic mixin when the mixin engine should be able to automatically close the mixin type.
            Without the attribute, an exception will be thrown.
            </para>
            <para>
            For example, consider the following code:
            <code>
            public class TargetClass&lt;T&gt; : ITargetClass { }
            
            [Extends (typeof (TargetClass&lt;&gt;))]
            public class MyMixin&lt;T&gt; where T : ITargetClass { }
            </code>
            To bind <c>T</c> to <c>ITargetClass</c>, use a binding specification:
            <code>
            public class TargetClass&lt;T&gt; : ITargetClass { }
            
            [Extends (typeof (TargetClass&lt;&gt;))]
            public class MyMixin&lt;[BindToConstraints]T&gt; where T : ITargetClass { }
            </code>
            </para>
            <para>
            <list type="bullet">
            <item>
            When there are no constraint or there is only a <c>class</c> constraint, the generic parameter is bound to <see cref="T:System.Object"/>.
            </item>
            <item>
            When there is only a struct constraint, the generic parameter is bound to <see cref="T:System.Int32"/>.
            </item>
            <item>
            When there are multiple interface, type, struct, and class constraints that cannot be unified into a single type, an exception is thrown.
            </item>
            </list>
            </para>
            <note type="inotes">When a type parameter is reused for the generic parameter of the <see cref="T:Remotion.Mixins.Mixin`2"/>
            or <see cref="T:Remotion.Mixins.Mixin`1"/> base classes, the type parameter must satisfy several constraints. See <see cref="T:Remotion.Mixins.Mixin`2"/> and
            <see cref="T:Remotion.Mixins.Mixin`1"/> for more information.</note>
            </remarks>
            <seealso cref="T:Remotion.Mixins.BindToTargetTypeAttribute"/>
            <seealso cref="T:Remotion.Mixins.BindToGenericTargetParameterAttribute"/>
        </member>
        <member name="T:Remotion.Mixins.BindToGenericTargetParameterAttribute">
            <summary>
            Indicates that a generic parameter of a mixin should be bound to the mixin's target type's generic parameter (unless the generic parameter 
            type is explicitly specified when the mixin is configured). Generic parameters with this attribute must be at the front of a mixin's generic
            parameter list, and they are mapped to the generic parameter of the target type by position.
            </summary>
            <remarks>
            <para>
            For example, consider the following code:
            <code>
            public class TargetClass&lt;T&gt; { }
            
            [Extends (typeof (TargetClass&lt;&gt;))]
            public class MyMixin&lt;[BindToGenericTargetParameter]T&gt; { }
            </code>
            To bind MyMixin's <c>T</c> to the <c>&lt;T&gt;</c> parameter of TargetClass, use the following code:
            <code>
            public class TargetClass&lt;T&gt; { }
            
            [Extends (typeof (TargetClass&lt;&gt;))]
            public class MyMixin&lt;[BindToGenericTargetParameter] T&gt; { }
            </code>
            </para>
            <note type="inotes">When a type parameter is reused for the generic parameter of the <see cref="T:Remotion.Mixins.Mixin`2"/>
            or <see cref="T:Remotion.Mixins.Mixin`1"/> base classes, the type parameter must satisfy several constraints. See <see cref="T:Remotion.Mixins.Mixin`2"/> and
            <see cref="T:Remotion.Mixins.Mixin`1"/> for more information.</note>
            </remarks>
            <seealso cref="T:Remotion.Mixins.BindToTargetTypeAttribute"/>
            <seealso cref="T:Remotion.Mixins.BindToConstraintsAttribute"/>
        </member>
        <member name="T:Remotion.Mixins.BindToTargetTypeAttribute">
            <summary>
            Indicates that a generic parameter of a mixin should be bound to the mixin's target type (unless the generic parameter type is explicitly
            specified when the mixin is configured).
            </summary>
            <remarks>
            <para>
            Apply this attribute to a generic parameter of a generic mixin when the mixin engine should be able to automatically close the mixin type.
            Without the attribute, an exception will be thrown.
            </para>
            <para>
            For example, consider the following code:
            <code>
            public class TargetClass&lt;T&gt; { }
            
            [Extends (typeof (TargetClass&lt;&gt;))]
            public class MyMixin&lt;T&gt; { }
            </code>
            To bind <c>T</c> to <c>TargetClass&lt;T&gt;</c>, use a binding specification:
            <code>
            public class TargetClass&lt;T&gt; { }
            
            [Extends (typeof (TargetClass&lt;&gt;))]
            public class MyMixin&lt;[BindToTargetType] T&gt; { }
            </code>
            </para>
            <note type="inotes">When a type parameter is reused for the generic parameter of the <see cref="T:Remotion.Mixins.Mixin`2"/>
            or <see cref="T:Remotion.Mixins.Mixin`1"/> base classes, the type parameter must satisfy several constraints. See <see cref="T:Remotion.Mixins.Mixin`2"/> and
            <see cref="T:Remotion.Mixins.Mixin`1"/> for more information.</note>
            </remarks>
            <seealso cref="T:Remotion.Mixins.BindToConstraintsAttribute"/>
            <seealso cref="T:Remotion.Mixins.BindToGenericTargetParameterAttribute"/>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.IConcreteTypeMetadataImporter">
            <summary>
            Assists in importing pre-generated concrete mixed and mixin types by analyzing the types and returning the respective metadata they were
            generated for.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.CodeGenerationCache">
            <summary>
            Implements caching of the types generated by <see cref="T:Remotion.Mixins.CodeGeneration.IModuleManager"/> instances, triggered by <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder"/>.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.ConcreteMixedTypeAttribute">
            <summary>
            Applied to concrete mixed types generated by the mixin engine.
            </summary>
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.ConcreteMixedTypeAttribute.FromClassContext(Remotion.Mixins.Context.ClassContext,System.Type[])">
            <summary>
            Creates a <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteMixedTypeAttribute"/> from a given <see cref="T:Remotion.Mixins.Context.ClassContext"/>.
            </summary>
            <param name="context">The class context describing the concrete mixed type.</param>
            <param name="orderedMixinTypes">The types of the mixins applied to the target class of this attribute in the same order that was used for the 
            code generation. The mixin types directly match the mixin types defined by <see cref="P:Remotion.Mixins.Definitions.TargetClassDefinition.Mixins"/>.</param>
            <returns>A new <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteMixedTypeAttribute"/> with the <see cref="P:Remotion.Mixins.CodeGeneration.ConcreteMixedTypeAttribute.ClassContextData"/> property holding a serialized version of
            <paramre name="context"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.ConcreteMixedTypeAttribute.#ctor(System.Object[],System.Type[])">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteMixedTypeAttribute"/> class.
            </summary>
            <param name="classContextData">The serialized class context data, produced by <see cref="T:Remotion.Mixins.Context.Serialization.AttributeClassContextSerializer"/>.</param>
            <param name="orderedMixinTypes">The types of the mixins applied to the target class of this attribute in the same order that was used for the 
            code generation. The mixin types directly match the mixin types defined by <see cref="P:Remotion.Mixins.Definitions.TargetClassDefinition.Mixins"/>.</param>
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.ConcreteMixedTypeAttribute.GetClassContext">
            <summary>
            Gets the class context describing the target type of this attribute.
            </summary>
            <returns>A deserialized form of <see cref="P:Remotion.Mixins.CodeGeneration.ConcreteMixedTypeAttribute.ClassContextData"/>.</returns>
        </member>
        <member name="P:Remotion.Mixins.CodeGeneration.ConcreteMixedTypeAttribute.ClassContextData">
            <summary>
            Gets the serialized class context data, readable by <see cref="T:Remotion.Mixins.Context.Serialization.AttributeClassContextDeserializer"/>. Use <see cref="M:Remotion.Mixins.CodeGeneration.ConcreteMixedTypeAttribute.GetClassContext"/> to
            deserialize this.
            </summary>
            <value>The serialized class context data.</value>
        </member>
        <member name="P:Remotion.Mixins.CodeGeneration.ConcreteMixedTypeAttribute.OrderedMixinTypes">
            <summary>
            Gets the types of the mixins applied to the target class of this attribute in the same order that was used for the code generation. The mixin
            types reflected by this property directly match the mixin types defined by <see cref="P:Remotion.Mixins.Definitions.TargetClassDefinition.Mixins"/>.
            </summary>
            <value>The ordered mixin types.</value>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.ConcreteMixinType">
            <summary>
            Holds the results of mixin code generation when a concrete mixin type was generated.
            </summary>
            <remarks>
            A concrete mixin type is a type derived from a mixin type that implements <see cref="T:Remotion.Mixins.OverrideMixinAttribute">mixin overrides</see> and holds
            public wrappers for protected methods needed to be accessed from the outside.
            </remarks>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeAttribute">
            <summary>
            This attribute is applied to concrete derived mixin types generated by the mixin engine.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier">
            <summary>
            Holds all information necessary to identify a concrete mixin type generated by <see cref="M:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder.GetConcreteMixinType(Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier)"/>.
            </summary>
            <remarks>
            <para>
            Comparing <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier"/> instances requires a comparison of the sets of <see cref="P:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier.Overriders"/> and
            <see cref="P:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier.Overridden"/> and should therefore not be performed in tight loops. Getting the hash code is, however, quite fast, as it
            is cached.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier.Deserialize(Remotion.Mixins.CodeGeneration.Serialization.IConcreteMixinTypeIdentifierDeserializer)">
            <summary>
            Deserializes an <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier"/> from the given deserializer.
            </summary>
            <param name="deserializer">The deserializer to use.</param>
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier.#ctor(System.Type,System.Collections.Generic.HashSet{System.Reflection.MethodInfo},System.Collections.Generic.HashSet{System.Reflection.MethodInfo})">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier"/> class.
            </summary>
            <param name="mixinType">The mixin type for which a concrete type was generated.</param>
            <param name="overriders">Mixin methods that override methods of the target class.</param>
            <param name="overridden">Mixin methods that are overridden by the target class.</param>
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier.Equals(System.Object)">
            <summary>
            Determines whether the specified <see cref="T:System.Object"/> is equal to this <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier"/>. Checks all 
            properties for equality, ignoring the order of the items in the <see cref="T:System.Reflection.MethodInfo"/> sets.
            </summary>
            <param name="obj">The <see cref="T:System.Object"/> to compare with the current <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier"/>.</param>
            <returns>
            true if the specified <see cref="T:System.Object"/> is an <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier"/> that corresponds to the same concrete
            mixin type; otherwise, false.
            </returns>
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier.GetHashCode">
            <summary>
            Serves as a hash function for this <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier"/>, matching the <see cref="M:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier.Equals(System.Object)"/> implementation.
            </summary>
            <returns>
            A hash code for the current <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier"/>.
            </returns>
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier.Serialize(Remotion.Mixins.CodeGeneration.Serialization.IConcreteMixinTypeIdentifierSerializer)">
            <summary>
            Serializes this object with the specified serializer.
            </summary>
            <param name="serializer">The serializer to use.</param>
        </member>
        <member name="P:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier.MixinType">
            <summary>
            Gets the mixin type for which a concrete type was generated.
            </summary>
            <value>The mixin type for which a concrete type was generated.</value>
        </member>
        <member name="P:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier.Overriders">
            <summary>
            Gets mixin methods that override methods of the target class. These are called by the mixin's target classes and may require public wrappers
            in the concrete mixin type.
            </summary>
            <value>Mixin methods that override methods of the target class.</value>
        </member>
        <member name="P:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier.Overridden">
            <summary>
            Gets the mixin methods that are overridden by the target class. These are overridden in the concrete mixin type and call back to the target
            classes.
            </summary>
            <value>Mixin methods that are overridden by the target class.</value>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder">
            <summary>
            Provides a way to build concrete types for target and mixin classes in mixin configurations and maintains a cache for built types.
            </summary>
            <remarks>
            <para>
            This class represents a thread-safe global singleton. You can access the single instance via the 
            <see cref="P:Remotion.Mixins.Utilities.Singleton.ThreadSafeSingletonBase`2.Current"/> property and replace it via the 
            <see cref="M:Remotion.Mixins.Utilities.Singleton.ThreadSafeSingletonBase`2.SetCurrent(`0)"/> method.
            </para>
            <para>
            The names of the assemblies generated by the <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder"/> is determined by the <see cref="T:Remotion.Mixins.CodeGeneration.IModuleManager"/> it uses.
            </para>
            </remarks>
            <threadsafety static="true" instance="true"/>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.IConcreteTypeBuilder">
            <summary>
            Provides a common interface for classes used to get concrete types for the mixin configuration.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.IConcreteTypeProvider">
            <summary>
            Provides a concrete, mixed type for a given <see cref="T:Remotion.Mixins.Context.ClassContext"/>.
            </summary>
            <remarks>
            This interface is mostly for internal reasons, users should use 
            <see cref="M:Remotion.Mixins.ObjectFactory.Create(System.Type,Remotion.Reflection.ParamList,System.Object[])"/> or <see cref="M:Remotion.Mixins.TypeFactory.GetConcreteType(System.Type)"/> 
            instead.
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.IConcreteTypeProvider.GetConcreteType(Remotion.Mixins.Context.ClassContext)">
            <summary>
            Gets a concrete mixed type for the given target class configuration.
            </summary>
            <param name="classContext">The <see cref="T:Remotion.Mixins.Context.ClassContext"/> holding the mixin configuration for the target class.</param>
            <returns>A concrete type with all mixins from <paramref name="classContext"/> mixed in.</returns>
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.IConcreteTypeProvider.GetConstructorLookupInfo(Remotion.Mixins.Context.ClassContext,System.Boolean)">
            <summary>
            Gets an <see cref="T:Remotion.Reflection.IConstructorLookupInfo"/> object that can be used to construct the concrete mixed type for the given target class
            configuration either from the cache or by generating it.
            </summary>
            <param name="classContext">The <see cref="T:Remotion.Mixins.Context.ClassContext"/> holding the mixin configuration for the target class.</param>
            <param name="allowNonPublic">If set to <see langword="true"/>, the result object supports calling non-public constructors. Otherwise,
            only public constructors are allowed.</param>
            <returns>
            An <see cref="T:Remotion.Reflection.IConstructorLookupInfo"/> instance instantiating the same type <see cref="M:Remotion.Mixins.CodeGeneration.IConcreteTypeProvider.GetConcreteType(Remotion.Mixins.Context.ClassContext)"/> would have returned for the given
            <paramref name="classContext"/>.
            </returns>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.IConcreteMixinTypeProvider">
            <summary>
            Provides a concrete mixin type for a given <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier"/>.
            </summary>
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.IConcreteMixinTypeProvider.GetConcreteMixinType(Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier)">
            <summary>
            Gets a concrete mixin type for the given mixin configuration.
            </summary>
            <param name="concreteMixinTypeIdentifier">The <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier"/> defining the mixin type to get.</param>
            <returns>A concrete mixin type for the given <paramref name="concreteMixinTypeIdentifier"/>.</returns>
            <remarks>This is mostly for internal reasons, users will hardly ever need to use this method.</remarks>
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.IConcreteTypeBuilder.SaveGeneratedConcreteTypes">
            <summary>
            Saves the concrete types and mixin types generated by this <see cref="T:Remotion.Mixins.CodeGeneration.IConcreteTypeBuilder"/> to disk. 
            </summary>
            <returns>An array containing the paths of the assembly files saved.</returns>
            <remarks>
            <para>
            Each time this method is called, only the types generated since the last call operation are persisted.
            </para>
            <para>
            Having different assemblies with the same names loaded into one AppDomain can lead to sporadic
            <see cref="T:System.TypeLoadException">TypeLoadExceptions</see> in reflective scenarios. To avoid such errors, the  
            <see cref="P:Remotion.Mixins.CodeGeneration.DynamicProxy.ModuleManager.SignedAssemblyName"/> and <see cref="P:Remotion.Mixins.CodeGeneration.DynamicProxy.ModuleManager.UnsignedAssemblyName"/> properties by default include a counter
            that is increased every time the scope is reset; that way, the assembly names change every time.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.IConcreteTypeBuilder.LoadConcreteTypes(System.Reflection.Assembly)">
            <summary>
            Imports the public concrete types and mixin types from the given <see cref="T:System.Reflection.Assembly"/> into this <see cref="T:Remotion.Mixins.CodeGeneration.IConcreteTypeBuilder"/> instance.
            The assembly should have been generated via <see cref="M:Remotion.Mixins.CodeGeneration.IConcreteTypeBuilder.SaveGeneratedConcreteTypes"/> or the TypeMixer utility.
            </summary>
            <param name="assembly">The assembly whose public types to load.</param>
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.IConcreteTypeBuilder.InitializeUnconstructedInstance(Remotion.Mixins.IMixinTarget)">
            <summary>
            Initializes a mixin target instance which was created without its constructor having been called (e.g., 
            <see cref="M:System.Runtime.Serialization.FormatterServices.GetSafeUninitializedObject(System.Type)"/>). For deserialized objects use <see cref="M:Remotion.Mixins.CodeGeneration.IConcreteTypeBuilder.InitializeDeserializedInstance(Remotion.Mixins.IMixinTarget,System.Object[])"/>.
            </summary>
            <param name="mixinTarget">The mixin target to initialize.</param>
            <exception cref="T:System.ArgumentNullException">The mixin target is <see langword="null"/>.</exception>
            <remarks>
            This method must be called when a mixin target instance is created without calling its constructor. Before this method is executed, the 
            target instance cannot be used.
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.IConcreteTypeBuilder.InitializeDeserializedInstance(Remotion.Mixins.IMixinTarget,System.Object[])">
            <summary>
            Initializes a mixin target instance which was created by deserialization.
            </summary>
            <param name="mixinTarget">The mixin target to initialize.</param>
            <param name="mixinInstances">The deserialized mixin instances for the <paramref name="mixinTarget"/>.</param>
            <exception cref="T:System.ArgumentNullException">The mixin target is <see langword="null"/>.</exception>
            <remarks>
            This method must be called when a mixin target instance is deserialized. Before this method is executed, the target instance cannot be used.
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.IConcreteTypeBuilder.BeginDeserialization(System.Func{System.Type,System.Type},System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Begins deserialization of a mixed object.
            </summary>
            <param name="typeTransformer">A transformation object that is given a chance to modify the deserialized type before it is instantiated.</param>
            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> object provided by the .NET serialization infrastructure.</param>
            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> object provided by the .NET serialization infrastructure.</param>
            <returns>An <see cref="T:System.Runtime.Serialization.IObjectReference"/> object containing a partially deserialized mixed object. Be sure to call
            <see cref="M:Remotion.Mixins.CodeGeneration.IConcreteTypeBuilder.FinishDeserialization(System.Runtime.Serialization.IObjectReference)"/> from an implementation of <see cref="M:System.Runtime.Serialization.IDeserializationCallback.OnDeserialization(System.Object)"/> to finish the
            deserialization process.</returns>
            <exception cref="T:System.ArgumentNullException">One or more of the parameters passed to this method are <see langword="null"/>.</exception>
            <exception cref="T:System.Runtime.Serialization.SerializationException">The serialization data does not hold the expected values.</exception>
            <remarks>
            <para>
            This method is useful when the mixin engine is combined with other code generation mechanisms. In such a case, the default
            <see cref="T:System.Runtime.Serialization.IObjectReference"/> implementation provided by the mixin code generation can be extended by a custom <see cref="T:System.Runtime.Serialization.IObjectReference"/>
            object by calling this method. This method instantiates the real object to be returned by the deserialization process, but the caller
            specifies a <paramref name="typeTransformer"/> delegate that gets the chance to modify the type of object before it is instantiated. The
            parameter passed to <paramref name="typeTransformer"/> is the type deducted from the deserialized mixin configuration.
            </para>
            <para>
            This method expects that the deserialized data is from a mixed object, calling it for an unmixed object will yield an exception.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.IConcreteTypeBuilder.FinishDeserialization(System.Runtime.Serialization.IObjectReference)">
            <summary>
            Finishes a deserialization process started by <see cref="M:Remotion.Mixins.CodeGeneration.IConcreteTypeBuilder.BeginDeserialization(System.Func{System.Type,System.Type},System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)"/>.
            </summary>
            <param name="objectReference">The object returned from <see cref="M:Remotion.Mixins.CodeGeneration.IConcreteTypeBuilder.BeginDeserialization(System.Func{System.Type,System.Type},System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)"/>.</param>
            <remarks>
            <exception cref="T:System.ArgumentNullException">The <paramref name="objectReference"/> parameter is <see langword="null"/>.</exception>
            <exception cref="T:Remotion.Utilities.ArgumentTypeException">The <paramref name="objectReference"/> parameter does not hold an object returned by the
            <see cref="M:Remotion.Mixins.CodeGeneration.IConcreteTypeBuilder.BeginDeserialization(System.Func{System.Type,System.Type},System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)"/> method.</exception>
            <para>
            Call this method to complete deserialization of a mixed object when the .NET serialization infrastructure has finished its
            work, e.g. from an implementation of <see cref="M:System.Runtime.Serialization.IDeserializationCallback.OnDeserialization(System.Object)"/>. After this method, the real object
            contained in <paramref name="objectReference"/> can safely be used.
            </para>
            <para>
            If the given instance is not an instance of a mixed type, this method does nothing.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder.LockAndAccessScope(System.Action{Remotion.Mixins.CodeGeneration.IModuleManager})">
            <summary>
            Provides thread-safe access to the module scope of <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder"/>, see also <see cref="P:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder.Scope"/>.
            </summary>
            <param name="scopeAccessor">A delegate accessing the scope while access to it is locked.</param>
            <remarks>This methods locks the scope while executing <paramref name="scopeAccessor"/>. This ensures that no other method of
            <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder"/> modifies the scope while it is being accessed.</remarks>
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder.GetConcreteType(Remotion.Mixins.Context.ClassContext)">
            <summary>
            Gets the concrete mixed type for the given target class configuration either from the cache or by generating it.
            </summary>
            <param name="classContext">The <see cref="T:Remotion.Mixins.Context.ClassContext"/> holding the mixin configuration for the target class.</param>
            <returns>A concrete type with all mixins from <paramref name="classContext"/> mixed in.</returns>
            <remarks>This is mostly for internal reasons, users should use <see cref="M:Remotion.Mixins.TypeFactory.GetConcreteType(System.Type)"/> instead.</remarks>
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder.GetConstructorLookupInfo(Remotion.Mixins.Context.ClassContext,System.Boolean)">
            <inheritdoc />
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder.GetConcreteMixinType(Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier)">
            <summary>
            Gets the concrete type for the given mixin class configuration either from the cache or by generating it.
            </summary>
            <param name="concreteMixinTypeIdentifier">The <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier"/> defining the mixin type to get.</param>
            <returns>A concrete type for the given <paramref name="concreteMixinTypeIdentifier"/>.</returns>
            <remarks>This is mostly for internal reasons, users will hardly ever need to use this method.</remarks>
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder.SaveGeneratedConcreteTypes">
            <summary>
            Saves the concrete types and mixin types generated by this <see cref="T:Remotion.Mixins.CodeGeneration.IConcreteTypeBuilder"/> to disk. The <see cref="P:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder.Scope"/> is reset, 
            so that the builder can continue to generate types.
            The names of the assemblies used by this method depend on the <see cref="P:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder.Scope"/>. It is recommended to provide a configured 
            <see cref="T:Remotion.Mixins.CodeGeneration.IModuleManager"/> instance when constructing the <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder"/> in order to configure the assembly names.
            </summary>
            <returns>An array containing the paths of the assembly files saved.</returns>
            <remarks>
            <para>
            This method is similar to directly calling <see cref="P:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder.Scope"/>.<see cref="M:Remotion.Mixins.CodeGeneration.IModuleManager.SaveAssemblies"/> , but in addition resets the 
            <see cref="P:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder.Scope"/> via <see cref="M:Remotion.Mixins.CodeGeneration.IModuleManager.Reset"/>. That way, the builder can continue to generate types even when the dynamic 
            assemblies have been saved. Note that each time this method is called, only the types generated since the last save operation are persisted. 
            Also, if the scope isn't reconfigured to save at different paths, previously saved assemblies might be overwritten.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder.LoadConcreteTypes(System.Reflection.Assembly)">
            <inheritdoc />
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder.LoadConcreteTypes(System.Runtime.InteropServices._Assembly)">
            <summary>
            Imports the public concrete types and mixin types from the given <see cref="T:System.Reflection.Assembly"/> into this <see cref="T:Remotion.Mixins.CodeGeneration.IConcreteTypeBuilder"/> instance.
            </summary>
            <param name="assembly">The assembly whose public types to load.</param>
            <remarks>
            This overload exists primarily for testing purposes; it has the same functionality as <see cref="M:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder.LoadConcreteTypes(System.Reflection.Assembly)"/>.
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder.InitializeUnconstructedInstance(Remotion.Mixins.IMixinTarget)">
            <inheritdoc />
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder.InitializeDeserializedInstance(Remotion.Mixins.IMixinTarget,System.Object[])">
            <inheritdoc />
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder.BeginDeserialization(System.Func{System.Type,System.Type},System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <inheritdoc />
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder.FinishDeserialization(System.Runtime.Serialization.IObjectReference)">
            <inheritdoc />
        </member>
        <member name="P:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder.Cache">
            <summary>
            Gets the cache used to cache types generated by this <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder"/>.
            </summary>
            <value>The cache used for building types.</value>
        </member>
        <member name="P:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder.Scope">
            <summary>
            Gets or sets the <see cref="T:Remotion.Mixins.CodeGeneration.IModuleManager"/> used by this <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder"/>. The object returned by this property must not 
            be used by multiple threads at the same time (or while another thread executes methods on <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder"/>) since it is
            not guaranteed to be thread-safe. Use <see cref="M:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder.LockAndAccessScope(System.Action{Remotion.Mixins.CodeGeneration.IModuleManager})"/> to access the <see cref="P:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder.Scope"/> in a thread-safe way.
            </summary>
            <value>The module scope of this <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder"/>.</value>
        </member>
        <member name="P:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder.TypeNameProvider">
            <summary>
            Gets the name provider used when generating a concrete mixed type.
            </summary>
        </member>
        <member name="P:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder.MixinTypeNameProvider">
            <summary>
            Gets the name provider used when generating a concrete mixin type.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.DynamicProxy.IInitializableMixinTarget">
            <summary>
            This interface is dynamically added to concrete mixed types generated by <see cref="T:Remotion.Mixins.CodeGeneration.DynamicProxy.TypeGenerator"/>. It is used to initialize a mixin
            after its construction or deserialization.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.IMixinTarget">
            <summary>
            This interface is implicitly implemented by all mixed types and objects returned by <see cref="T:Remotion.Mixins.TypeFactory"/> and <see cref="T:Remotion.Mixins.ObjectFactory"/>.
            </summary>
        </member>
        <member name="P:Remotion.Mixins.IMixinTarget.ClassContext">
            <summary>
            Gets the mixin target's configuration data.
            </summary>
            <value>A <see cref="P:Remotion.Mixins.IMixinTarget.ClassContext"/> object holding the configuration data used to create the mixin target.</value>
        </member>
        <member name="P:Remotion.Mixins.IMixinTarget.Mixins">
            <summary>
            Gets the mixins associated with the mixed object.
            </summary>
            <value>The mixin instances associated with the mixed object.</value>
        </member>
        <member name="P:Remotion.Mixins.IMixinTarget.FirstNextCallProxy">
            <summary>
            Gets the first base call proxy.
            </summary>
            <value>An object the mixin type uses to call overridden methods. This is an instance of a generated type with no defined public API, so
            it is only useful for internal purposes.</value>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.DynamicProxy.OverrideInterfaceMappingAttribute">
            <summary>
            Defines a mapping between an overridden mixin member and the member in the mixin's override interface. The attribute is applied to the members
            of the interface so that the mixin member can be determined when needed.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.DynamicProxy.TypeGeneration.DebuggerBrowsableAttributeGenerator">
            <summary>
            Generates the <see cref="T:System.Diagnostics.DebuggerBrowsableAttribute"/> on the given emitted members, this hiding them from the debugger.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.DynamicProxy.TypeGeneration.DebuggerDisplayAttributeGenerator">
            <summary>
            Generates the <see cref="T:System.Diagnostics.DebuggerDisplayAttribute"/> on the given emitted members or classes.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.DynamicProxy.TypeGeneration.ImplementedInterfaceFinder">
            <summary>
            Finds the interfaces to be implemented by the generated type.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.DynamicProxy.TypeGeneration.InitializationCodeGenerator">
            <summary>
            Generates the initialization code used to initialize a concrete mixed type and its mixins.
            </summary>
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.DynamicProxy.TypeGeneration.InitializationCodeGenerator.GetInitializationStatement">
            <summary>
            Gets a <see cref="T:Castle.DynamicProxy.Generators.Emitters.SimpleAST.Statement"/> that causes the mixin to initialize itself. This effectively calls the 
            <see cref="M:Remotion.Mixins.CodeGeneration.DynamicProxy.IInitializableMixinTarget.Initialize"/> method added by <see cref="M:Remotion.Mixins.CodeGeneration.DynamicProxy.TypeGeneration.InitializationCodeGenerator.ImplementIInitializableMixinTarget(Remotion.Reflection.CodeGeneration.IClassEmitter,Castle.DynamicProxy.Generators.Emitters.SimpleAST.FieldReference)"/>.
            </summary>
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.DynamicProxy.TypeGeneration.InitializationCodeGenerator.ImplementIInitializableMixinTarget(Remotion.Reflection.CodeGeneration.IClassEmitter,Castle.DynamicProxy.Generators.Emitters.SimpleAST.FieldReference)">
            <summary>
            Implements the <see cref="T:Remotion.Mixins.CodeGeneration.DynamicProxy.IInitializableMixinTarget"/> interface on the given <paramref name="classEmitter"/>.
            </summary>
            <param name="classEmitter">The class emitter to generate <see cref="T:Remotion.Mixins.CodeGeneration.DynamicProxy.IInitializableMixinTarget"/> on.</param>
            <param name="mixinArrayInitializerField">The field holding the <see cref="T:Remotion.Mixins.CodeGeneration.MixinArrayInitializer"/> used to initialize the mixins.</param>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.DynamicProxy.TypeGeneration.IntroducedMemberAttributeGenerator">
            <summary>
            Generates the <see cref="T:Remotion.Mixins.CodeGeneration.IntroducedMemberAttribute"/> on introduced members.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.DynamicProxy.TypeGeneration.MixinTargetCodeGenerator">
            <summary>
            Generates code needed to implement <see cref="T:Remotion.Mixins.IMixinTarget"/> on concrete mixed types.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.DynamicProxy.TypeGeneration.OverrideInterfaceImplementer">
            <summary>
            When a concrete mixed type is generated, this class implements the override interfaces of the mixins applied to the target class.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.DynamicProxy.TypeGeneration.TypeInitializerCodeGenerator">
            <summary>
            Generates code required to implement a type initializer on a concrete mixed type.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.GuidNameProvider">
            <summary>
            Returns names for concrete mixed or mixin types by extending the type name of the target or mixin class with a <see cref="T:System.Guid"/>. That way,
            unique names are generated.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.IConcreteMixedTypeNameProvider">
            <summary>
            Defines an interface for classes providing a mechanism to retrieve a name for a generated concrete mixed type.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.IConcreteMixinTypeNameProvider">
            <summary>
            Defines an interface for classes providing a mechanism to retrieve a name for a generated concrete mixin type.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.IntroducedMemberAttribute">
            <summary>
            Added to a member introduced by a mixin on the generated concrete type.
            </summary>
        </member>
        <member name="P:Remotion.Mixins.CodeGeneration.IntroducedMemberAttribute.Mixin">
            <summary>
            Gets the mixin that added the member.
            </summary>
            <value>The mixin that added the member.</value>
        </member>
        <member name="P:Remotion.Mixins.CodeGeneration.IntroducedMemberAttribute.MixinMemberName">
            <summary>
            Gets the name of the member as it is defined by the <see cref="P:Remotion.Mixins.CodeGeneration.IntroducedMemberAttribute.Mixin"/>.
            </summary>
            <value>The name of the member on the <see cref="P:Remotion.Mixins.CodeGeneration.IntroducedMemberAttribute.Mixin"/>.</value>
        </member>
        <member name="P:Remotion.Mixins.CodeGeneration.IntroducedMemberAttribute.IntroducedInterface">
            <summary>
            Gets the interface defining the introduced member.
            </summary>
            <value>The interface defining the member.</value>
        </member>
        <member name="P:Remotion.Mixins.CodeGeneration.IntroducedMemberAttribute.InterfaceMemberName">
            <summary>
            Gets the name of the member as it is defined by the <see cref="P:Remotion.Mixins.CodeGeneration.IntroducedMemberAttribute.IntroducedInterface"/>.
            </summary>
            <value>The name of the member on the <see cref="P:Remotion.Mixins.CodeGeneration.IntroducedMemberAttribute.IntroducedInterface"/>.</value>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.MixinArrayInitializer">
            <summary>
            Initializes the mixin array held by generated concrete mixed types.
            </summary>
        </member>
        <member name="M:Remotion.Mixins.CodeGeneration.MixinArrayInitializer.#ctor(System.Type,System.Type[])">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Mixins.CodeGeneration.MixinArrayInitializer"/> class.
            </summary>
            <param name="targetType">Target type of which the concrete mixed type was generated. This is mainly used for error messages.</param>
            <param name="expectedMixinTypes">The expected mixin types. For derived mixins, these contain the concrete mixed types.</param>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.NamespaceChangingNameProvider">
            <summary>
            Returns names for concrete mixed types by extending the type name of the target class with an additional namespace. This name provider
            cannot be used to return names for concrete mixin types those types wouldn't be uniquely identifiable if only the namespace was changed. 
            Use <see cref="T:Remotion.Mixins.CodeGeneration.GuidNameProvider"/> instead.
            </summary>
            <remarks>
            This provider can lead to name conflicts if it is used to generate multiple concrete types for the same target type, for example because
            the mixin configuration has changed. In such scenarios, a unique name provider, such as <see cref="T:Remotion.Mixins.CodeGeneration.GuidNameProvider"/>, should be preferred.
            </remarks>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.Serialization.AttributeConcreteMixinTypeIdentifierDeserializer">
            <summary>
            Serializes instances of <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier"/> into a format that can be used as a custom attribute parameter.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.Serialization.AttributeConcreteMixinTypeIdentifierSerializer">
            <summary>
            Deserializes instances of <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier"/> serialized with <see cref="T:Remotion.Mixins.CodeGeneration.Serialization.AttributeConcreteMixinTypeIdentifierSerializer"/>.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.Serialization.SerializationInfoConcreteMixinTypeIdentifierDeserializer">
            <summary>
            Deserializes instances of <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier"/> serialized with 
            <see cref="T:Remotion.Mixins.CodeGeneration.Serialization.SerializationInfoConcreteMixinTypeIdentifierSerializer"/>.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.Serialization.SerializationInfoConcreteMixinTypeIdentifierSerializer">
            <summary>
            Serializes instances of <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteMixinTypeIdentifier"/> into a <see cref="T:System.Runtime.Serialization.SerializationInfo"/> object. The serialization is
            completely flat, using only primitive types, so the returned object is always guaranteed to be complete even in the face of the order of 
            deserialization of objects not being deterministic.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.CodeGeneration.TypeImportException">
            <summary>
            Thrown when a concrete type should be imported, but the import fails.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.CompleteInterfaceAttribute">
            <summary>
            Indicates that an interface acts as a complete interface for a class instantiated via <see cref="T:Remotion.Mixins.ObjectFactory"/>.
            </summary>
            <remarks>
            <para>
            A complete interface combines the API of a target type with that of its mixins. For example, if a target class provides the methods A and B
            and a mixin adds the methods C and D, users of the class could normally only use either A and B or C and D at the same time (without casting).
            By implementing a complete interface that provides methods A, B, C, and D, users of the class can employ the full API in a simple way.
            </para>
            <para>
            All methods directly specified by a complete interface must be implemented by the target type. If the complete interface extends a set of
            other interfaces, those interfaces can either be implemented by the target class or be introduced by a mixin. This enables the complete 
            interface to provide access both to methods on the target type and to those introduced by mixins.
            </para>
            <para>
            This attribute can be applied multiple times if an interface is to be a complete interface for multiple target types. The attribute is not
            inherited, i.e. an interface inheriting from a complete interface does not automatically constitute a complete interface as well.
            </para>
            </remarks>
            <example>
            <code>
            public class MyMixinTarget
            {
              public void A() { Console.WriteLine ("A"); }
              public void B() { Console.WriteLine ("B"); }
            }
            
            public interface IMyMixin
            {
              void C();
              void D();
            }
            
            [Extends (typeof (MyMixinTarget))]
            public class MyMixin : Mixin&lt;MyMixinTarget&gt;, IMyMixin
            {
              public void C() { Console.WriteLine ("D"); }
              public void D() { Console.WriteLine ("D"); }
            }
            
            [CompleteInterface (typeof (MyMixinTarget))]
            public interface ICMyMixinTargetMyMixin : IMyMixin
            {
              void A();
              void B();
            }
            </code>
            </example>
        </member>
        <member name="M:Remotion.Mixins.CompleteInterfaceAttribute.#ctor(System.Type)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Mixins.CompleteInterfaceAttribute"/> class.
            </summary>
            <param name="targetType">Target type for which this interface constitutes a complete interface.</param>
        </member>
        <member name="P:Remotion.Mixins.CompleteInterfaceAttribute.TargetType">
            <summary>
            Gets the target type for which this interface constitutes a complete interface.
            </summary>
            <value>The target type of this complete interface.</value>
        </member>
        <member name="T:Remotion.Mixins.ComposedObject`1">
            <summary>
            Acts as a convenience base class for domain objects in the mixin-based composition pattern. Provides a <see cref="P:Remotion.Mixins.ComposedObject`1.This"/> property that 
            allows access to the composed interface, and a <see cref="M:Remotion.Mixins.ComposedObject`1.NewObject``1(Remotion.Reflection.ParamList)"/> factory method for subclasses.
            </summary>
            <typeparam name="TComposedInterface">The composed interface of the derived class. This interface defines the members available via
            the <see cref="P:Remotion.Mixins.ComposedObject`1.This"/> property. See the Remarks section for details. Each composed interface can only be associated with one single subclass
            of <see cref="T:Remotion.Mixins.ComposedObject`1"/>.
            </typeparam>
            <remarks>
            <para>
            When a class inherits members provided by mixins, those additional members are only available by casting the class instance to the respective 
            interfaces introduced by the mixins. This can be cumbersome, so the concept of complete
            interfaces was added. A complete interface combines public members of the
            mixed class with members introduced by mixins. The target class members are added to the complete interface either by having the
            complete interface extend an interface also implemented by the target class, or by simply redeclaring the members of the target class on the
            complete interface. The mixin members are added to the complete interface by having the complete interface extend the interfaces 
            introduced by the mixins. For an example, see the documentation for the <see cref="T:Remotion.Mixins.CompleteInterfaceAttribute"/>.
            </para>
            <para>
            While complete interfaces provide easy access to the members added by mixins, they still require one cast (from the target class instance to
            the complete interface). To remove the need for this cast, classes implementing mixin-based composition can use the 
            <see cref="T:Remotion.Mixins.ComposedObject`1"/> base class. When a class derives from <see cref="T:Remotion.Mixins.ComposedObject`1"/>, 
            it defines a complete interface for itself and all
            the mixins it composes via the <see cref="T:Remotion.Mixins.UsesAttribute"/>. That complete interface is called the <typeparamref name="TComposedInterface"/>.
            </para>
            <para>
            The <see cref="T:Remotion.Mixins.ComposedObject`1"/> base class associates the <typeparamref name="TComposedInterface"/> with the derived class 
            and provides a <see cref="P:Remotion.Mixins.ComposedObject`1.This"/> property allowing access to all the members provided by the class and the composed mixins. Use the
            <see cref="P:Remotion.Mixins.ComposedObject`1.This"/> property as the full public API of the class.
            </para>
            <para>
            The base class checks that the derived class is always instantiated by the mixin engine, and it will throw an exception from its constructor 
            if this is not the case.
            </para>
            </remarks>
        </member>
        <member name="T:Remotion.Mixins.IHasCompleteInterface`1">
            <summary>
            Defines <typeparamref name="TInterface"/> as a complete interface for the target class implementing the <see cref="T:Remotion.Mixins.IHasCompleteInterface`1"/> interface.
            </summary>
            <typeparam name="TInterface">The complete interface type.</typeparam>
            <remarks>
            <para>
            Complete interfaces are interfaces that comprise members implemented on a target class as well as members added by mixins to that target class.
            They can be used to access all members on a mixed instance without casting to mixin interfaces.
            </para>
            <para>
            For more information, see <see cref="T:Remotion.Mixins.CompleteInterfaceAttribute"/>. Implementing <see cref="T:Remotion.Mixins.IHasCompleteInterface`1"/> on a target 
            class has the same effect as marking the respective <typeparamref name="TInterface"/> with the <see cref="T:Remotion.Mixins.CompleteInterfaceAttribute"/>.
            </para>
            <para>
            <see cref="T:Remotion.Mixins.IHasCompleteInterface`1"/> is automatically taken into account when the declarative mixin configuration is analyzed.
            When building a mixin configuration using the fluent mixin building APIs (<see cref="M:Remotion.Mixins.MixinConfiguration.BuildNew()"/> and 
            similar), it is not automatically taken into account. Register the interface by hand using 
            <see cref="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.AddCompleteInterface{TInterface}()"/>.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.ComposedObject`1.NewObject``1(Remotion.Reflection.ParamList)">
            <summary>
            Used to create instances of the class derived from <see cref="T:Remotion.Mixins.ComposedObject`1"/>.
            </summary>
            <typeparam name="TComposite">The type of the composite domain object to create. This must be a subclass of 
            <see cref="T:Remotion.Mixins.ComposedObject`1"/>.</typeparam>
            <param name="ctorArgs">The constructor arguments.</param>
            <returns>An instance of <typeparamref name="TComposite"/>, accessed via the <typeparamref name="TComposedInterface"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.ComposedObject`1.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Mixins.ComposedObject`1"/> class and checks that the instance was created by
            the mixin engine.
            </summary>
            <exception cref="T:System.InvalidOperationException">The instance was not created by the mixin engine. Use the <see cref="M:Remotion.Mixins.ComposedObject`1.NewObject``1(Remotion.Reflection.ParamList)"/>
            factory method, the <see cref="T:Remotion.Mixins.ObjectFactory"/>, or the <see cref="T:Remotion.Mixins.TypeFactory"/> to instantiate subclasses of 
            <see cref="T:Remotion.Mixins.ComposedObject`1"/>.</exception>
        </member>
        <member name="P:Remotion.Mixins.ComposedObject`1.This">
            <summary>
            Gets this <see cref="T:Remotion.Mixins.ComposedObject`1"/> instance via the <typeparamref name="TComposedInterface"/> interface type. 
            This enables callers to access the members of all composed mixins without explicit casts.
            </summary>
            <value>This instance, accessed via the <typeparamref name="TComposedInterface"/>.</value>
        </member>
        <member name="T:Remotion.Mixins.ConfigurationException">
            <summary>
            Thrown when there is a severe error in the mixin configuration which is detected during configuration analysis. The problem prevents
            the configuration from being fully analyzed. See also <see cref="T:Remotion.Mixins.Validation.ValidationException"/>.
            </summary>
        </member>
        <member name="M:Remotion.Mixins.ConfigurationException.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Mixins.ConfigurationException"/> class.
            </summary>
            <param name="message">The exception message.</param>
        </member>
        <member name="M:Remotion.Mixins.ConfigurationException.#ctor(System.String,System.Exception)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Mixins.ConfigurationException"/> class.
            </summary>
            <param name="message">The exception message.</param>
            <param name="innerException">The inner exception.</param>
        </member>
        <member name="M:Remotion.Mixins.ConfigurationException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Mixins.ConfigurationException"/> class during deserialization.
            </summary>
            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"></see> that holds the serialized object data about the exception being thrown.</param>
            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"></see> that contains contextual information about the source or destination.</param>
            <exception cref="T:System.ArgumentNullException">The info parameter is null. </exception>
        </member>
        <member name="T:Remotion.Mixins.Context.ClassContext">
            <summary>
            Holds the mixin configuration information for a single mixin target class.
            </summary>
            <threadsafety static="true" instance="true"/>
            <remarks>
            Instances of this class are immutable.
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.Context.ClassContext.#ctor(System.Type,System.Collections.Generic.IEnumerable{Remotion.Mixins.Context.MixinContext},System.Collections.Generic.IEnumerable{System.Type})">
            <summary>
            Initializes a new <see cref="T:Remotion.Mixins.Context.ClassContext"/> for a given mixin target type.
            </summary>
            <param name="type">The mixin target type to be represented by this context.</param>
            <param name="mixins">A list of <see cref="T:Remotion.Mixins.Context.MixinContext"/> objects representing the mixins applied to this class.</param>
            <param name="completeInterfaces">The complete interfaces supported by the class.</param>
            <exception cref="T:System.ArgumentNullException">The <paramref name="type"/> parameter is <see langword="null"/>.</exception>
        </member>
        <member name="M:Remotion.Mixins.Context.ClassContext.#ctor(System.Type)">
            <summary>
            Initializes a new <see cref="T:Remotion.Mixins.Context.ClassContext"/> for a given target type without mixins.
            </summary>
            <param name="type">The mixin target type to be represented by this context.</param>
            <exception cref="T:System.ArgumentNullException">The <paramref name="type"/> parameter is <see langword="null"/>.</exception>
        </member>
        <member name="M:Remotion.Mixins.Context.ClassContext.#ctor(System.Type,Remotion.Mixins.Context.MixinContext[])">
            <summary>
            Initializes a new <see cref="T:Remotion.Mixins.Context.ClassContext"/> for a given mixin target type.
            </summary>
            <param name="type">The mixin target type to be represented by this context.</param>
            <param name="mixins">A list of <see cref="T:Remotion.Mixins.Context.MixinContext"/> objects representing the mixins applied to this class.</param>
            <exception cref="T:System.ArgumentNullException">The <paramref name="type"/> parameter is <see langword="null"/>.</exception>
        </member>
        <member name="M:Remotion.Mixins.Context.ClassContext.#ctor(System.Type,System.Type[])">
            <summary>
            Initializes a new <see cref="T:Remotion.Mixins.Context.ClassContext"/> for a given mixin target type and initializes it to be associated with the given
            mixin types.
            </summary>
            <param name="type">The mixin target type to be represented by this context.</param>
            <param name="mixinTypes">The mixin types to be associated with this context.</param>
            <exception cref="T:System.ArgumentNullException">One of the parameters passed to this method is <see langword="null"/>.</exception>
            <exception cref="T:System.ArgumentException">The <paramref name="mixinTypes"/> parameter contains duplicates.</exception>
        </member>
        <member name="M:Remotion.Mixins.Context.ClassContext.IsEmpty">
            <summary>
            Determines whether this <see cref="T:Remotion.Mixins.Context.ClassContext"/> is empty, i.e. it contains no <see cref="P:Remotion.Mixins.Context.ClassContext.Mixins"/> or <see cref="P:Remotion.Mixins.Context.ClassContext.CompleteInterfaces"/>.
            </summary>
            <returns>
            	<see langword="true"/> if this <see cref="T:Remotion.Mixins.Context.ClassContext"/> is empty; otherwise, <see langword="false"/>.
            </returns>
        </member>
        <member name="M:Remotion.Mixins.Context.ClassContext.Equals(System.Object)">
            <summary>
            Determines whether the specified <see cref="T:System.Object"></see> is equal to the current <see cref="T:Remotion.Mixins.Context.ClassContext"/>.
            </summary>
            <param name="obj">The <see cref="T:System.Object"></see> to compare with this <see cref="T:Remotion.Mixins.Context.ClassContext"/>.</param>
            <returns>
            True if the specified <see cref="T:System.Object"></see> is a <see cref="T:Remotion.Mixins.Context.ClassContext"/> for the same type with equal mixin 
            and complete interfaces configuration; otherwise, false.
            </returns>
        </member>
        <member name="M:Remotion.Mixins.Context.ClassContext.GetHashCode">
            <summary>
            Returns a hash code for this <see cref="T:Remotion.Mixins.Context.ClassContext"/>.
            </summary>
            <returns>
            A hash code for the current <see cref="T:Remotion.Mixins.Context.ClassContext"/> which includes the hash codes of this object's complete interfaces and mixin ocntexts.
            </returns>
        </member>
        <member name="M:Remotion.Mixins.Context.ClassContext.ToString">
            <summary>
            Returns a <see cref="T:System.String"></see> that represents the current <see cref="T:Remotion.Mixins.Context.ClassContext"/>.
            </summary>
            <returns>
            A <see cref="T:System.String"></see> containing the type names of this context's associated <see cref="P:Remotion.Mixins.Context.ClassContext.Type"/>, all its mixin types, and
            complete interfaces.
            </returns>
        </member>
        <member name="M:Remotion.Mixins.Context.ClassContext.CloneForSpecificType(System.Type)">
            <summary>
            Returns a new <see cref="T:Remotion.Mixins.Context.ClassContext"/> with the same mixins and complete interfaces as this object, but a different target type.
            </summary>
            <param name="type">The target type to create the new <see cref="T:Remotion.Mixins.Context.ClassContext"/> for.</param>
            <returns>A clone of this <see cref="T:Remotion.Mixins.Context.ClassContext"/> for a different target type.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.ClassContext.SpecializeWithTypeArguments(System.Type[])">
            <summary>
            Creates a clone of the current class context, replacing its generic parameters with type arguments. This method is only allowed on
            class contexts representing a generic type definition.
            </summary>
            <param name="genericArguments">The type arguments to specialize this context's <see cref="P:Remotion.Mixins.Context.ClassContext.Type"/> with.</param>
            <returns>A <see cref="T:Remotion.Mixins.Context.ClassContext"/> which is identical to this one except its <see cref="P:Remotion.Mixins.Context.ClassContext.Type"/> being specialized with the
            given <paramref name="genericArguments"/>.</returns>
            <exception cref="T:System.ArgumentNullException">The <paramref name="genericArguments"/> parameter is <see langword="null"/>.</exception>
            <exception cref="T:System.InvalidOperationException"><see cref="P:Remotion.Mixins.Context.ClassContext.Type"/> is not a generic type definition.</exception>
        </member>
        <member name="M:Remotion.Mixins.Context.ClassContext.InheritFrom(Remotion.Mixins.Context.ClassContext)">
            <summary>
            Creates a new <see cref="T:Remotion.Mixins.Context.ClassContext"/> inheriting all data from the given <paramref name="baseContext"/> and applying overriding rules for
            mixins and concrete interfaces already defined for this <see cref="T:Remotion.Mixins.Context.ClassContext"/>.
            </summary>
            <param name="baseContext">The base context to inherit data from.</param>
            <returns>A new <see cref="T:Remotion.Mixins.Context.ClassContext"/> combining the mixins of this object with those from the <paramref name="baseContext"/>.</returns>
            <exception cref="T:Remotion.Mixins.ConfigurationException">The <paramref name="baseContext"/> contains mixins whose base types or generic
            type definitions are already defined on this mixin. The derived context cannot have concrete mixins whose base types
            are defined on the parent context.
            </exception>
        </member>
        <member name="M:Remotion.Mixins.Context.ClassContext.InheritFrom(System.Collections.Generic.IEnumerable{Remotion.Mixins.Context.ClassContext})">
            <summary>
            Creates a new <see cref="T:Remotion.Mixins.Context.ClassContext"/> inheriting all data from the given <paramref name="baseContexts"/> and applying overriding rules for
            mixins and concrete interfaces already defined for this <see cref="T:Remotion.Mixins.Context.ClassContext"/>.
            </summary>
            <param name="baseContexts">The base contexts to inherit data from.</param>
            <returns>A new <see cref="T:Remotion.Mixins.Context.ClassContext"/> combining the mixins of this object with those from the <paramref name="baseContexts"/>.</returns>
            <exception cref="T:Remotion.Mixins.ConfigurationException">The <paramref name="baseContexts"/> contain mixins whose base types or generic
            type definitions are already defined on this mixin. The derived context cannot have concrete mixins whose base types
            are defined on the parent context.
            </exception>
        </member>
        <member name="M:Remotion.Mixins.Context.ClassContext.SuppressMixins(System.Collections.Generic.IEnumerable{Remotion.Mixins.Context.Suppression.IMixinSuppressionRule})">
            <summary>
            Returns a new <see cref="T:Remotion.Mixins.Context.ClassContext"/> equivalent to this object but with all mixins affected by the given 
            <paramref name="suppressionRules"/> removed.
            </summary>
            <param name="suppressionRules">The rules describing the mixin types to suppress.</param>
            <returns>
            A copy of this <see cref="T:Remotion.Mixins.Context.ClassContext"/> without any mixins that are affected by the given <parmref name="suppressionRules"/>.
            </returns>
        </member>
        <member name="P:Remotion.Mixins.Context.ClassContext.Type">
            <summary>
            Gets the type represented by this <see cref="T:Remotion.Mixins.Context.ClassContext"/>.
            </summary>
            <value>The type represented by this context.</value>
        </member>
        <member name="P:Remotion.Mixins.Context.ClassContext.Mixins">
            <summary>
            Gets the mixins associated with this <see cref="T:Remotion.Mixins.Context.ClassContext"/>.
            </summary>
            <value>The mixins associated with this context.</value>
        </member>
        <member name="P:Remotion.Mixins.Context.ClassContext.CompleteInterfaces">
            <summary>
            Gets the complete interfaces associated with this <see cref="T:Remotion.Mixins.Context.ClassContext"/>.
            </summary>
            <value>The complete interfaces associated with this context (for an explanation, see <see cref="T:Remotion.Mixins.CompleteInterfaceAttribute"/>).</value>
        </member>
        <member name="T:Remotion.Mixins.Context.ClassContextCollection">
            <summary>
            Holds the <see cref="T:Remotion.Mixins.Context.ClassContext"/> instances for a <see cref="T:Remotion.Mixins.MixinConfiguration"/>, providing easy means to search exactly for a given type
            (<see cref="M:Remotion.Mixins.Context.ClassContextCollection.GetExact(System.Type)"/>) and with inheritance rules (<see cref="M:Remotion.Mixins.Context.ClassContextCollection.GetWithInheritance(System.Type)"/>).
            This class is immutable, i.e., it is initialized on construction and cannot be changed later on.
            </summary>
            <threadsafety static="true" instance="true"/>
        </member>
        <member name="T:Remotion.Mixins.Context.DeclarativeConfigurationBuilder">
            <summary>
            Provides support for building mixin configuration data from the declarative mixin configuration attributes
            (<see cref="T:Remotion.Mixins.UsesAttribute"/>, <see cref="T:Remotion.Mixins.ExtendsAttribute"/>, <see cref="T:Remotion.Mixins.CompleteInterfaceAttribute"/>,
            and <see cref="T:Remotion.Mixins.IgnoreForMixinConfigurationAttribute"/>).
            </summary>
            <threadsafety static="true" instance="false"/>
        </member>
        <member name="M:Remotion.Mixins.Context.DeclarativeConfigurationBuilder.BuildConfigurationFromAssemblies(System.Reflection.Assembly[])">
            <summary>
            Builds a new <see cref="T:Remotion.Mixins.MixinConfiguration"/> from the declarative configuration information in the given assemblies without inheriting
            from a parent configuration.
            </summary>
            <param name="assemblies">The assemblies to be scanned for declarative mixin information.</param>
            <returns>A mixin configuration incorporating the configuration information held by the given assemblies.</returns>
            <exception cref="T:System.ArgumentNullException">The <paramref name="assemblies"/> parameter is <see langword="null"/>.</exception>
        </member>
        <member name="M:Remotion.Mixins.Context.DeclarativeConfigurationBuilder.BuildConfigurationFromAssemblies(Remotion.Mixins.MixinConfiguration,System.Reflection.Assembly[])">
            <summary>
            Builds a new <see cref="T:Remotion.Mixins.MixinConfiguration"/> from the declarative configuration information in the given assemblies.
            </summary>
            <param name="parentConfiguration">The parent configuration to derive the new configuration from (can be <see langword="null"/>).</param>
            <param name="assemblies">The assemblies to be scanned for declarative mixin information.</param>
            <returns>A mixin configuration inheriting from <paramref name="parentConfiguration"/> and incorporating the configuration information
            held by the given assemblies.</returns>
            <exception cref="T:System.ArgumentNullException">The <paramref name="assemblies"/> parameter is <see langword="null"/>.</exception>
        </member>
        <member name="M:Remotion.Mixins.Context.DeclarativeConfigurationBuilder.BuildConfigurationFromAssemblies(Remotion.Mixins.MixinConfiguration,System.Collections.Generic.IEnumerable{System.Reflection.Assembly})">
            <summary>
            Builds a new <see cref="T:Remotion.Mixins.MixinConfiguration"/> from the declarative configuration information in the given assemblies.
            </summary>
            <param name="parentConfiguration">The parent configuration to derive the new configuration from (can be <see langword="null"/>).</param>
            <param name="assemblies">The assemblies to be scanned for declarative mixin information.</param>
            <returns>An mixin configuration inheriting from <paramref name="parentConfiguration"/> and incorporating the configuration information
            held by the given assemblies.</returns>
            <exception cref="T:System.ArgumentNullException">The <paramref name="assemblies"/> parameter is <see langword="null"/>.</exception>
        </member>
        <member name="M:Remotion.Mixins.Context.DeclarativeConfigurationBuilder.BuildConfigurationFromTypes(Remotion.Mixins.MixinConfiguration,System.Collections.Generic.IEnumerable{System.Type})">
            <summary>
            Builds a new <see cref="T:Remotion.Mixins.MixinConfiguration"/> from the declarative configuration information in the given types.
            </summary>
            <param name="parentConfiguration">The parent configuration to derive the new configuration from (can be <see langword="null"/>).</param>
            <param name="types">The types to be scanned for declarative mixin information.</param>
            <returns>A mixin configuration inheriting from <paramref name="parentConfiguration"/> and incorporating the configuration information
            held by the given types.</returns>
            <exception cref="T:System.ArgumentNullException">The <paramref name="types"/> parameter is <see langword="null"/>.</exception>
        </member>
        <member name="M:Remotion.Mixins.Context.DeclarativeConfigurationBuilder.BuildDefaultConfiguration">
            <summary>
            Builds the default application configuration by analyzing all assemblies in the application bin directory and their (directly or indirectly)
            referenced assemblies for mixin configuration information. System assemblies are not scanned.
            </summary>
            <returns>A mixin configuration holding the default mixin configuration information for this application.</returns>
            <remarks>This method uses the <see cref="T:Remotion.Reflection.TypeDiscovery.ContextAwareTypeDiscoveryUtility"/> to discover the types to be used in the mixin configuration.
            In design mode, this will use the types returned by the designer, but in ordinary application scenarios, the following steps are performed:
            <list type="number">
            <item>Retrieve all types assemblies from the current <see cref="T:System.AppDomain">AppDomain's</see> bin directory.</item>
            <item>Analyze each of them that is included by the <see cref="T:Remotion.Reflection.TypeDiscovery.AssemblyLoading.ApplicationAssemblyLoaderFilter"/> for mixin configuration information.</item>
            <item>Load the referenced assemblies of those assemblies if they aren't excluded by the <see cref="T:Remotion.Reflection.TypeDiscovery.AssemblyLoading.ApplicationAssemblyLoaderFilter"/>.</item>
            <item>If the loaded assemblies haven't already been analyzed, treat them according to steps 2-4.</item>
            </list>
            </remarks>
            <seealso cref="T:Remotion.Reflection.TypeDiscovery.ContextAwareTypeDiscoveryUtility"/>
        </member>
        <member name="M:Remotion.Mixins.Context.DeclarativeConfigurationBuilder.#ctor(Remotion.Mixins.MixinConfiguration)">
            <summary>
            Initializes a new <see cref="T:Remotion.Mixins.Context.DeclarativeConfigurationBuilder"/>, which can be used to collect assemblies and types with declarative
            mixin configuration attributes in order to build an <see cref="T:Remotion.Mixins.MixinConfiguration"/>.
            </summary>
            <param name="parentConfiguration">The parent configuration used when this instance builds a new <see cref="T:Remotion.Mixins.MixinConfiguration"/>.</param>
        </member>
        <member name="M:Remotion.Mixins.Context.DeclarativeConfigurationBuilder.AddAssembly(System.Reflection.Assembly)">
            <summary>
            Scans the given assembly for declarative mixin configuration information and stores the information for a later call to <see cref="M:Remotion.Mixins.Context.DeclarativeConfigurationBuilder.BuildConfiguration"/>.
            The mixin configuration information of types marked with the <see cref="T:Remotion.Mixins.IgnoreForMixinConfigurationAttribute"/> will be ignored.
            </summary>
            <param name="assembly">The assembly to be scanned.</param>
            <returns>A reference to this <see cref="T:Remotion.Mixins.Context.DeclarativeConfigurationBuilder"/> object.</returns>
            <exception cref="T:System.ArgumentNullException">The <paramref name="assembly"/> parameter is <see langword="null"/>.</exception>
        </member>
        <member name="M:Remotion.Mixins.Context.DeclarativeConfigurationBuilder.AddType(System.Type)">
            <summary>
            Scans the given type for declarative mixin configuration information and stores the information for a later call to <see cref="M:Remotion.Mixins.Context.DeclarativeConfigurationBuilder.BuildConfiguration"/>.
            The type will be scanned whether or not is is marked with the <see cref="T:Remotion.Mixins.IgnoreForMixinConfigurationAttribute"/>.
            </summary>
            <param name="type">The type to be scanned. This must be a non-generic type or a generic type definition. Closed generic types are not
            supported to be scanned.</param>
            <returns>A reference to this <see cref="T:Remotion.Mixins.Context.DeclarativeConfigurationBuilder"/> object.</returns>
            <exception cref="T:System.ArgumentNullException">The <paramref name="type"/> parameter is <see langword="null"/>.</exception>
            <exception cref="T:System.ArgumentException">The given type is a closed generic type and not a generic type definition.</exception>
        </member>
        <member name="M:Remotion.Mixins.Context.DeclarativeConfigurationBuilder.BuildConfiguration">
            <summary>
            Analyzes the information added so far to this builder and creates a new <see cref="T:Remotion.Mixins.MixinConfiguration"/> from that data.
            </summary>
            <returns>An <see cref="T:Remotion.Mixins.MixinConfiguration"/> derived from the configuration specified in the builder's constructor containing
            <see cref="T:Remotion.Mixins.Context.ClassContext"/> and <see cref="T:Remotion.Mixins.Context.MixinContext"/> objects based on the information added so far.</returns>
        </member>
        <member name="T:Remotion.Mixins.Context.DefaultMixinInheritancePolicy">
            <summary>
            Encapsulates the rules governing mixin inheritance for target types.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.Context.IMixinInheritancePolicy">
            <summary>
            Provides a public interface for objects encapsulating the rules governing mixin inheritance for target types.
            </summary>
        </member>
        <member name="M:Remotion.Mixins.Context.IMixinInheritancePolicy.GetTypesToInheritFrom(System.Type)">
            <summary>
            Gets the types this <paramref name="targetType"/> inherits mixins from. A target type inherits mixins from its generic type definition,
            its base class, and its interfaces.
            </summary>
            <param name="targetType">The type whose "base" types should be retrieved.</param>
            <returns>The types from which the given <paramref name="targetType"/> inherits its mixins.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.IMixinInheritancePolicy.GetClassContextsToInheritFrom(System.Type,System.Func{System.Type,Remotion.Mixins.Context.ClassContext})">
            <summary>
            Gets the class contexts this <paramref name="targetType"/> inherits mixins from. A target type inherits mixins from its generic type 
            definition, its base class, and its interfaces.
            </summary>
            <param name="targetType">The type whose "base" <see cref="T:Remotion.Mixins.Context.ClassContext"/> instances should be retrieved.</param>
            <param name="classContextRetriever">A function returning the <see cref="T:Remotion.Mixins.Context.ClassContext"/> for a given type.</param>
            <returns><see cref="T:Remotion.Mixins.Context.ClassContext"/> objects for the types from which the given <paramref name="targetType"/> inherits its mixins.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.DefaultMixinInheritancePolicy.GetTypesToInheritFrom(System.Type)">
            <summary>
            Gets the types this <paramref name="targetType"/> inherits mixins from. A target type inherits mixins from its generic type definition,
            its base class, and its interfaces.
            </summary>
            <param name="targetType">The type whose "base" types should be retrieved.</param>
            <returns>The types from which the given <paramref name="targetType"/> inherits its mixins.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.DefaultMixinInheritancePolicy.GetClassContextsToInheritFrom(System.Type,System.Func{System.Type,Remotion.Mixins.Context.ClassContext})">
            <summary>
            Gets the class contexts this <paramref name="targetType"/> inherits mixins from. A target type inherits mixins from its generic type 
            definition, its base class, and its interfaces.
            </summary>
            <param name="targetType">The type whose "base" <see cref="T:Remotion.Mixins.Context.ClassContext"/> instances should be retrieved.</param>
            <param name="classContextRetriever">A function returning the <see cref="T:Remotion.Mixins.Context.ClassContext"/> for a given type.</param>
            <returns><see cref="T:Remotion.Mixins.Context.ClassContext"/> objects for the types from which the given <paramref name="targetType"/> inherits its mixins.</returns>
        </member>
        <member name="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder">
            <summary>
            Assists <see cref="T:Remotion.Mixins.Context.FluentBuilders.MixinConfigurationBuilder"/> by providing a fluent interface for building <see cref="T:Remotion.Mixins.Context.ClassContext"/> objects.
            </summary>
            <remarks>
            This class gathers configuration data to be associated with a specific <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>. That data is combined with inherited
            contexts (from base classes or parent configuration, for example) and pushed into a <see cref="T:Remotion.Mixins.Context.ClassContext"/> by the 
            <see cref="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.BuildClassContext(System.Collections.Generic.IEnumerable{Remotion.Mixins.Context.ClassContext})"/> method. That method is called
            by <see cref="M:Remotion.Mixins.Context.FluentBuilders.MixinConfigurationBuilder.BuildConfiguration"/>.
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.Clear">
            <summary>
            Clears all mixin configuration for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>. This causes the target type to ignore all mixin configuration data from its
            parent context and also resets all information collected so far for the class by this object.
            </summary>
            <returns>This object for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.AddMixin(System.Type)">
            <summary>
            Collects the given type as a mixin for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.
            </summary>
            <param name="mixinType">The mixin type to collect.</param>
            <returns>A <see cref="T:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder"/> object for further configuration of the mixin.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.AddMixin``1">
            <summary>
            Collects the given type as a mixin for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.
            </summary>
            <typeparam name="TMixin">The mixin type to collect.</typeparam>
            <returns>A <see cref="T:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder"/> object for further configuration of the mixin.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.AddMixins(System.Type[])">
            <summary>
            Collects the given types as mixins for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.
            </summary>
            <param name="mixinTypes">The mixin types to collect.</param>
            <returns>This object for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.AddMixins``2">
            <summary>
            Collects the given types as mixins for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.
            </summary>
            <typeparam name="TMixin1">The first mixin type to collect.</typeparam>
            <typeparam name="TMixin2">The second mixin type to collect.</typeparam>
            <returns>This object for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.AddMixins``3">
            <summary>
            Collects the given types as mixins for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.
            </summary>
            <typeparam name="TMixin1">The first mixin type to collect.</typeparam>
            <typeparam name="TMixin2">The second mixin type to collect.</typeparam>
            <typeparam name="TMixin3">The third mixin type to collect.</typeparam>
            <returns>This object for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.EnsureMixin(System.Type)">
            <summary>
            Ensures that the given type is configured as a mixin for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>, adding it if necessary. The mixin will not be
            added if it has been taken over from the parent context (unless <see cref="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.Clear"/> was called); if added, it will override corresponding
            mixins inherited from a base type.
            </summary>
            <param name="mixinType">The mixin type to collect.</param>
            <returns>This object for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.EnsureMixin``1">
            <summary>
            Ensures that the given type is configured as a mixin for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>, adding it if necessary. The mixin will not be
            added if it has been taken over from the parent context (unless <see cref="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.Clear"/> was called); if added, it will override corresponding
            mixins inherited from a base type.
            </summary>
            <typeparam name="TMixin">The mixin type to collect.</typeparam>
            <returns>This object for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.EnsureMixins(System.Type[])">
            <summary>
            Ensures that the given types are configured as mixins for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>, adding them if necessary. The mixins will not be
            added if they has been taken over from the parent context (unless <see cref="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.Clear"/> was called); if added, they will override corresponding
            mixins inherited from a base type.
            </summary>
            <param name="mixinTypes">The mixin types to collect.</param>
            <returns>This object for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.EnsureMixins``2">
            <summary>
            Ensures that the given types are configured as mixins for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>, adding them if necessary. The mixins will not be
            added if they has been taken over from the parent context (unless <see cref="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.Clear"/> was called); if added, they will override corresponding
            mixins inherited from a base type.
            </summary>
            <typeparam name="TMixin1">The first mixin type to collect.</typeparam>
            <typeparam name="TMixin2">The second mixin type to collect.</typeparam>
            <returns>This object for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.EnsureMixins``3">
            <summary>
            Ensures that the given types are configured as mixins for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>, adding them if necessary. The mixins will not be
            added if they has been taken over from the parent context (unless <see cref="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.Clear"/> was called); if added, they will override corresponding
            mixins inherited from a base type.
            </summary>
            <typeparam name="TMixin1">The first mixin type to collect.</typeparam>
            <typeparam name="TMixin2">The second mixin type to collect.</typeparam>
            <typeparam name="TMixin3">The third mixin type to collect.</typeparam>
            <returns>This object for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.AddOrderedMixins(System.Type[])">
            <summary>
            Collects the given types as mixins for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/> and adds dependencies between the mixins to ensure a proper base call
            order.
            </summary>
            <param name="mixinTypes">The mixin types to collect with dependencies.</param>
            <returns>This object for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.AddOrderedMixins``2">
            <summary>
            Collects the given types as mixins for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/> and adds dependencies between the mixins to ensure a proper base call
            order.
            </summary>
            <typeparam name="TMixin1">The first mixin type to collect with dependencies.</typeparam>
            <typeparam name="TMixin2">The second mixin type to collect with dependencies.</typeparam>
            <returns>This object for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.AddOrderedMixins``3">
            <summary>
            Collects the given types as mixins for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/> and adds dependencies between the mixins to ensure a proper base call
            order.
            </summary>
            <typeparam name="TMixin1">The first mixin type to collect with dependencies.</typeparam>
            <typeparam name="TMixin2">The second mixin type to collect with dependencies.</typeparam>
            <typeparam name="TMixin3">The third mixin type to collect with dependencies.</typeparam>
            <returns>This object for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.AddCompleteInterface(System.Type)">
            <summary>
            Adds the given type as a complete interface to the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>. A complete interface can contain both members defined by the
            target class itself and by mixins applied to the class, making it easier to invoke methods and properties on a mixed object without casting.
            </summary>
            <param name="interfaceType">The type to collect as a complete interface.</param>
            <returns>This object for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.AddCompleteInterface``1">
            <summary>
            Adds the given type as a complete interface to the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>. A complete interface can contain both members defined by the
            target class itself and by mixins applied to the class, making it easier to invoke methods and properties on a mixed object without casting.
            </summary>
            <typeparam name="TInterface">The type to collect as a complete interface.</typeparam>
            <returns>This object for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.AddCompleteInterfaces(System.Type[])">
            <summary>
            Adds the given types as complete interfaces to the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>. A complete interface can contain both members defined by the
            target class itself and by mixins applied to the class, making it easier to invoke methods and properties on a mixed object without casting.
            </summary>
            <param name="interfaceTypes">The types to collect as complete interfaces.</param>
            <returns>This object for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.AddCompleteInterfaces``2">
            <summary>
            Adds the given types as complete interfaces to the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>. A complete interface can contain both members defined by the
            target class itself and by mixins applied to the class, making it easier to invoke methods and properties on a mixed object without casting.
            </summary>
            <typeparam name="TInterface1">The types to collect as complete interfaces.</typeparam>
            <typeparam name="TInterface2">The types to collect as complete interfaces.</typeparam>
            <returns>This object for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.AddCompleteInterfaces``3">
            <summary>
            Adds the given types as complete interfaces to the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>. A complete interface can contain both members defined by the
            target class itself and by mixins applied to the class, making it easier to invoke methods and properties on a mixed object without casting.
            </summary>
            <typeparam name="TInterface1">The types to collect as complete interfaces.</typeparam>
            <typeparam name="TInterface2">The types to collect as complete interfaces.</typeparam>
            <typeparam name="TInterface3">The types to collect as complete interfaces.</typeparam>
            <returns>This object for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.SuppressMixin(Remotion.Mixins.Context.Suppression.IMixinSuppressionRule)">
            <summary>
            Denotes that specific mixin types should be ignored in the context of this class. Suppression is helpful when a target class should take 
            over most of its mixins from the parent context or inherit mixins from another type, but a specific mixin should be ignored in that process.
            </summary>
            <param name="rule">A <see cref="T:Remotion.Mixins.Context.Suppression.IMixinSuppressionRule"/> denoting mixin types to be suppressed.</param>
            <returns>This object for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.SuppressMixin(System.Type)">
            <summary>
            Denotes that a specific mixin type, and all mixin types that can be ascribed to it (see <see cref="M:Remotion.Utilities.ReflectionUtility.CanAscribe(System.Type,System.Type)"/>), should be
            ignored in the context of this class. Suppression is helpful when a target class should take over most of its mixins from the
            parent context or inherit mixins from another type, but a specific mixin should be ignored in that process.
            </summary>
            <param name="mixinType">The mixin type, base type, or generic type definition denoting mixin types to be suppressed.</param>
            <returns>This object for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.SuppressMixin``1">
            <summary>
            Denotes that a specific mixin type, and all mixin types that can be ascribed to it (see <see cref="M:Remotion.Utilities.ReflectionUtility.CanAscribe(System.Type,System.Type)"/>), should be
            ignored in the context of this class. Suppression is helpful when a target class should take over most of its mixins from the
            parent context or inherit mixins from another type, but a specific mixin should be ignored in that process.
            </summary>
            <typeparam name="TMixinType">The mixin type, base type, or generic type definition denoting mixin types to be suppressed.</typeparam>
            <returns>This object for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.SuppressMixins(System.Type[])">
            <summary>
            Denotes that a number of mixin types, and all mixin types that can be ascribed to it (see <see cref="M:Remotion.Utilities.ReflectionUtility.CanAscribe(System.Type,System.Type)"/>), should be
            ignored in the context of this class. Suppression is helpful when a target class should take over most of its mixins from the
            parent context or inherit mixins from another type, but a specific mixin should be ignored in that process.
            </summary>
            <param name="mixinTypes">The mixin types, base types, or generic type definitions denoting mixin types to be suppressed.</param>
            <returns>This object for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.SuppressMixins``2">
            <summary>
            Denotes that a number of mixin types, and all mixin types that can be ascribed to it (see <see cref="M:Remotion.Utilities.ReflectionUtility.CanAscribe(System.Type,System.Type)"/>), should be
            ignored in the context of this class. Suppression is helpful when a target class should take over most of its mixins from the
            parent context or inherit mixins from another type, but a specific mixin should be ignored in that process.
            </summary>
            <typeparam name="TMixinType1">The first mixin type, base type, or generic type definition denoting mixin types to be suppressed.</typeparam>
            <typeparam name="TMixinType2">The second mixin type, base type, or generic type definition denoting mixin types to be suppressed.</typeparam>
            <returns>This object for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.SuppressMixins``3">
            <summary>
            Denotes that a number of mixin types, and all mixin types that can be ascribed to it (see <see cref="M:Remotion.Utilities.ReflectionUtility.CanAscribe(System.Type,System.Type)"/>), should be
            ignored in the context of this class. Suppression is helpful when a target class should take over most of its mixins from the
            parent context or inherit mixins from another type, but a specific mixin should be ignored in that process.
            </summary>
            <typeparam name="TMixinType1">The first mixin type, base type, or generic type definition denoting mixin types to be suppressed.</typeparam>
            <typeparam name="TMixinType2">The second mixin type, base type, or generic type definition denoting mixin types to be suppressed.</typeparam>
            <typeparam name="TMixinType3">The third mixin type, base type, or generic type definition denoting mixin types to be suppressed.</typeparam>
            <returns>This object for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.BuildClassContext(System.Collections.Generic.IEnumerable{Remotion.Mixins.Context.ClassContext})">
            <summary>
            Builds a class context with the data collected so far for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/> that inherits from other contexts.
            </summary>
            <param name="inheritedContexts">A collection of <see cref="T:Remotion.Mixins.Context.ClassContext"/> instances the newly built context should inherit mixin data from.</param>
            <returns>A <see cref="T:Remotion.Mixins.Context.ClassContext"/> for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/> holding all mixin configuration data collected so far.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.BuildClassContext">
            <summary>
            Builds a class context with the data collected so far for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/> without inheriting from other contexts.
            </summary>
            <returns>A <see cref="T:Remotion.Mixins.Context.ClassContext"/> for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/> holding all mixin configuration data collected so far.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.ForClass(System.Type)">
            <summary>
            Begins configuration of another target class.
            </summary>
            <param name="targetType">The class to be configured.</param>
            <returns>A fluent interface object for configuring the given <paramref name="targetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.ForClass``1">
            <summary>
            Begins configuration of another target class.
            </summary>
            <typeparam name="TTargetType">The class to be configured.</typeparam>
            <returns>A fluent interface object for configuring the given <typeparamref name="TTargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.BuildConfiguration">
            <summary>
            Builds a configuration object with the data gathered so far.
            </summary>
            <returns>A new <see cref="T:Remotion.Mixins.MixinConfiguration"/> instance incorporating all the data acquired so far.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.EnterScope">
            <summary>
            Builds a configuration object and calls the <see cref="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.EnterScope"/> method on it, thus activating the configuration for the current
            thread. The previous configuration is restored when the returned object's <see cref="M:System.IDisposable.Dispose"/> method is called (e.g. by a
            using statement).
            </summary>
            <returns>An <see cref="T:System.IDisposable"/> object for restoring the original configuration.</returns>
        </member>
        <member name="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.Parent">
            <summary>
            Gets the <see cref="T:Remotion.Mixins.Context.FluentBuilders.MixinConfigurationBuilder"/> used for creating this <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/>.
            </summary>
            <value>This object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.MixinConfigurationBuilder"/>.</value>
        </member>
        <member name="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType">
            <summary>
            Gets the type configured by this <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/>.
            </summary>
            <value>The target type configured by this object.</value>
        </member>
        <member name="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.MixinContextBuilders">
            <summary>
            Gets the mixin context builders collected so far.
            </summary>
            <value>The mixin context builders collected so far by this object.</value>
        </member>
        <member name="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.CompleteInterfaces">
            <summary>
            Gets the complete interfaces collected so far.
            </summary>
            <value>The complete interfaces collected so far by this object.</value>
        </member>
        <member name="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.SuppressedMixins">
            <summary>
            Gets the suppressed mixins collected so far.
            </summary>
            <value>The suppressed mixins collected so far by this object.</value>
        </member>
        <member name="T:Remotion.Mixins.Context.FluentBuilders.InheritanceResolvingClassContextBuilder">
            <summary>
            Builds <see cref="T:Remotion.Mixins.Context.ClassContext"/> instances from <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/> objects and applies inheritance from a parent configuration 
            and the types indicated by a <see cref="T:Remotion.Mixins.Context.IMixinInheritancePolicy"/>.
            This is done as follows:
            <list type="bullet">
            <item>A <see cref="T:Remotion.Mixins.Context.ClassContext"/> that exists in the parent configuration is kept as is, unless there is a 
            <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/> for the same type.</item>
            <item>A <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/> is transformed into a new <see cref="T:Remotion.Mixins.Context.ClassContext"/>:</item>
              <list type="bullet">
              <item>First, the <see cref="T:Remotion.Mixins.Context.ClassContext"/> objects for its base classes and interfaces are retrieved or created.</item> 
              <item>Then, the corresponding <see cref="T:Remotion.Mixins.Context.ClassContext"/> from the parent configuration is retrieved.</item>
              <item>Then, a new <see cref="T:Remotion.Mixins.Context.ClassContext"/> is created from the <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/>; inheriting everything from the base
              and parent contexts.</item>
              </list>
            </list>
            </summary>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.InheritanceResolvingClassContextBuilder.#ctor(System.Collections.Generic.IEnumerable{Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder},Remotion.Mixins.Context.ClassContextCollection,Remotion.Mixins.Context.IMixinInheritancePolicy)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Mixins.Context.FluentBuilders.InheritanceResolvingClassContextBuilder"/> class.
            </summary>
            <param name="classContextBuilders">All class context builders relevant for the inheritance hierarchy of the target types involved.</param>
            <param name="parentContexts">The <see cref="T:Remotion.Mixins.Context.ClassContext"/> instances defined by the parent configuration.</param>
            <param name="inheritancePolicy">The inheritance policy to use when resolving the inheritance hierarchy of the target types.</param>
        </member>
        <member name="T:Remotion.Mixins.Context.FluentBuilders.MixinConfigurationBuilder">
            <summary>
            Provides a fluent interface for building <see cref="T:Remotion.Mixins.MixinConfiguration"/> objects.
            </summary>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinConfigurationBuilder.ForClass(System.Type)">
            <summary>
            Begins configuration of a target class.
            </summary>
            <param name="targetType">The class to be configured.</param>
            <returns>A fluent interface object for configuring the given <paramref name="targetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinConfigurationBuilder.ForClass``1">
            <summary>
            Begins configuration of a target class.
            </summary>
            <typeparam name="TTargetType">The class to be configured.</typeparam>
            <returns>A fluent interface object for configuring the given <typeparamref name="TTargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinConfigurationBuilder.AddMixinToClass(Remotion.Mixins.MixinKind,System.Type,System.Type,Remotion.Mixins.MemberVisibility,System.Collections.Generic.IEnumerable{System.Type},System.Collections.Generic.IEnumerable{System.Type})">
            <summary>
            Adds the given mixin to the given target type with a number of explicit dependencies and suppressed mixins. This is a shortcut
            method for calling <see cref="M:Remotion.Mixins.Context.FluentBuilders.MixinConfigurationBuilder.ForClass(System.Type)"/>, <see cref="M:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.AddMixin(System.Type)"/>, <see cref="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.WithDependencies(System.Type[])"/>,
            and <see cref="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.ReplaceMixins(System.Type[])"/> in a row.
            </summary>
            <param name="mixinKind">The kind of relationship the mixin has with its target class.</param>
            <param name="targetType">The target type to add a mixin for.</param>
            <param name="mixinType">The mixin type to add.</param>
            <param name="introducedMemberVisibility">The default visibility to be used for introduced members.</param>
            <param name="explicitDependencies">The explicit dependencies of the mixin in the context of the target type.</param>
            <param name="suppressedMixins">The mixins suppressed by this mixin in the context of the target type.</param>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinConfigurationBuilder.BuildConfiguration">
            <summary>
            Builds a configuration object with the data gathered so far.
            </summary>
            <returns>A new <see cref="T:Remotion.Mixins.MixinConfiguration"/> instance incorporating all the data acquired so far.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinConfigurationBuilder.EnterScope">
            <summary>
            Builds a configuration object and calls the <see cref="M:Remotion.Mixins.Context.FluentBuilders.MixinConfigurationBuilder.EnterScope"/> method on it, thus activating the configuration for the current
            thread. The previous configuration is restored when the returned object's <see cref="M:System.IDisposable.Dispose"/> method is called (e.g. by a
            using statement).
            </summary>
            <returns>An <see cref="T:System.IDisposable"/> object for restoring the original configuration.</returns>
        </member>
        <member name="P:Remotion.Mixins.Context.FluentBuilders.MixinConfigurationBuilder.ParentConfiguration">
            <summary>
            Gets the parent configuration used as a base for the newly built mixin configuration.
            </summary>
            <value>The parent configuration.</value>
        </member>
        <member name="P:Remotion.Mixins.Context.FluentBuilders.MixinConfigurationBuilder.ClassContextBuilders">
            <summary>
            Gets the class context builders collected so far via the fluent interfaces.
            </summary>
            <value>The class context builders collected so far.</value>
        </member>
        <member name="T:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder">
            <summary>
            Assists <see cref="T:Remotion.Mixins.Context.FluentBuilders.MixinConfigurationBuilder"/> by providing a fluent interface for building <see cref="T:Remotion.Mixins.Context.MixinContext"/> objects.
            </summary>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.OfKind(Remotion.Mixins.MixinKind)">
            <summary>
            Defines the relationship the mixin has with its target class, which influences whether the mixin overrides attributes and interfaces
            of the target class, or the other way around. For more information see <see cref="T:Remotion.Mixins.MixinKind"/>. The default value
            is <see cref="F:Remotion.Mixins.MixinKind.Extending"/>.
            </summary>
            <param name="kind">The mixin kind.</param>
            <returns>This object for further configuration of the mixin.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.WithDependency(System.Type)">
            <summary>
            Collects a dependency for the configured <see cref="P:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.MixinType"/>. A dependency causes a base call ordering to be defined between two mixins:
            if mixin A depends on mixin B and both override the same methods, A's overrides will be called before B's overrides when an overridden member
            is invoked.
            </summary>
            <param name="requiredMixin">The mixin required by the configured <see cref="P:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.MixinType"/>.</param>
            <returns>This object for further configuration of the mixin.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.WithDependency``1">
            <summary>
            Collects a dependency for the configured <see cref="P:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.MixinType"/>. A dependency causes a base call ordering to be defined between two mixins:
            if mixin A depends on mixin B and both override the same methods, A's overrides will be called before B's overrides when an overridden member
            is invoked.
            </summary>
            <typeparam name="TRequiredMixin">The mixin (or an interface) required by the configured <see cref="P:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.MixinType"/>.</typeparam>
            <returns>This object for further configuration of the mixin.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.WithDependencies(System.Type[])">
            <summary>
            Collects a number of dependencies for the configured <see cref="P:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.MixinType"/>. A dependency causes a base call ordering to be defined between
            two mixins:
            if mixin A depends on mixin B and both override the same methods, A's overrides will be called before B's overrides when an overridden member
            is invoked.
            </summary>
            <param name="requiredMixins">The mixins (or interfaces) required by the configured <see cref="P:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.MixinType"/>.</param>
            <returns>This object for further configuration of the mixin.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.WithDependencies``2">
            <summary>
            Collects a number of dependencies for the configured <see cref="P:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.MixinType"/>. A dependency causes a base call ordering to be defined between
            two mixins:
            if mixin A depends on mixin B and both override the same methods, A's overrides will be called before B's overrides when an overridden member
            is invoked.
            </summary>
            <typeparam name="TMixin1">The first mixin (or interface) required by the configured <see cref="P:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.MixinType"/>.</typeparam>
            <typeparam name="TMixin2">The second mixin (or interface) required by the configured <see cref="P:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.MixinType"/>.</typeparam>
            <returns>This object for further configuration of the mixin.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.WithDependencies``3">
            <summary>
            Collects a number of dependencies for the configured <see cref="P:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.MixinType"/>. A dependency causes a base call ordering to be defined between
            two mixins:
            if mixin A depends on mixin B and both override the same methods, A's overrides will be called before B's overrides when an overridden member
            is invoked.
            </summary>
            <typeparam name="TMixin1">The first mixin (or interface) required by the configured <see cref="P:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.MixinType"/>.</typeparam>
            <typeparam name="TMixin2">The second mixin (or interface) required by the configured <see cref="P:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.MixinType"/>.</typeparam>
            <typeparam name="TMixin3">The third mixin (or interface) required by the configured <see cref="P:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.MixinType"/>.</typeparam>
            <returns>This object for further configuration of the mixin.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.WithIntroducedMemberVisibility(Remotion.Mixins.MemberVisibility)">
            <summary>
            Sets the default visibility of members introduced by this mixin to the given <paramref name="memberVisibility"/>.
            </summary>
            <param name="memberVisibility">The default member visibility to be used.</param>
            <returns>This object for further configuration of the mixin.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.ReplaceMixin(System.Type)">
            <summary>
            Denotes that a specific mixin type, and all mixin types that can be ascribed to it (see <see cref="M:Remotion.Utilities.ReflectionUtility.CanAscribe(System.Type,System.Type)"/>), should be
            replaced by this mixin type.
            </summary>
            <param name="replacedMixinType">The mixin type, base type, or generic type definition denoting mixin types to be replaced.</param>
            <returns>This object for further configuration of the mixin.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.ReplaceMixin``1">
            <summary>
            Denotes that a specific mixin type, and all mixin types that can be ascribed to it (see <see cref="M:Remotion.Utilities.ReflectionUtility.CanAscribe(System.Type,System.Type)"/>), should be
            replaced by this mixin type.
            </summary>
            <typeparam name="TReplacedMixinType">The mixin type, base type, or generic type definition denoting mixin types to be replaced.</typeparam>
            <returns>This object for further configuration of the mixin.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.ReplaceMixins(System.Type[])">
            <summary>
            Denotes that specific mixin types, and all mixin types that can be ascribed to them (see <see cref="M:Remotion.Utilities.ReflectionUtility.CanAscribe(System.Type,System.Type)"/>), should be
            replaced by this mixin type.
            </summary>
            <param name="replacedMixinTypes">The mixin types, base types, or generic type definitions denoting mixin types to be replaced.</param>
            <returns>This object for further configuration of the mixin.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.ReplaceMixins``2">
            <summary>
            Denotes that specific mixin types, and all mixin types that can be ascribed to them (see <see cref="M:Remotion.Utilities.ReflectionUtility.CanAscribe(System.Type,System.Type)"/>), should be
            replaced by this mixin type.
            </summary>
            <typeparam name="TReplacedMixinType1">The first mixin type, base type, or generic type definition denoting mixin types to be replaced.</typeparam>
            <typeparam name="TReplacedMixinType2">The second mixin type, base type, or generic type definition denoting mixin types to be replaced.</typeparam>
            <returns>This object for further configuration of the mixin.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.ReplaceMixins``3">
            <summary>
            Denotes that specific mixin types, and all mixin types that can be ascribed to them (see <see cref="M:Remotion.Utilities.ReflectionUtility.CanAscribe(System.Type,System.Type)"/>), should be
            replaced by this mixin type.
            </summary>
            <typeparam name="TReplacedMixinType1">The first mixin type, base type, or generic type definition denoting mixin types to be replaced.</typeparam>
            <typeparam name="TReplacedMixinType2">The second mixin type, base type, or generic type definition denoting mixin types to be replaced.</typeparam>
            <typeparam name="TReplacedMixinType3">The third mixin type, base type, or generic type definition denoting mixin types to be replaced.</typeparam>
            <returns>This object for further configuration of the mixin.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.BuildMixinContext">
            <summary>
            Builds a mixin context with the data collected so far for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.MixinType"/>.
            </summary>
            <returns>A <see cref="T:Remotion.Mixins.Context.MixinContext"/> holding all mixin configuration data collected so far.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.Clear">
            <summary>
            Clears all mixin configuration for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.Parent"/>'s <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>. This causes the target type to ignore
            all mixin configuration data from its
            parent context and also resets all information collected so far for the class by this object.
            </summary>
            <returns>This object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/> for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.AddMixin(System.Type)">
            <summary>
            Collects the given type as a mixin for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.
            </summary>
            <param name="mixinType">The mixin type to collect.</param>
            <returns>A <see cref="T:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder"/> object for further configuration of the mixin.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.AddMixin``1">
            <summary>
            Collects the given type as a mixin for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.
            </summary>
            <typeparam name="TMixin">The mixin type to collect.</typeparam>
            <returns>A <see cref="T:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder"/> object for further configuration of the mixin.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.AddMixins(System.Type[])">
            <summary>
            Collects the given types as mixins for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.
            </summary>
            <param name="mixinTypes">The mixin types to collect.</param>
            <returns>This object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/> for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.AddMixins``2">
            <summary>
            Collects the given types as mixins for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.
            </summary>
            <typeparam name="TMixin1">The first mixin type to collect.</typeparam>
            <typeparam name="TMixin2">The second mixin type to collect.</typeparam>
            <returns>This object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/> for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.AddMixins``3">
            <summary>
            Collects the given types as mixins for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.
            </summary>
            <typeparam name="TMixin1">The first mixin type to collect.</typeparam>
            <typeparam name="TMixin2">The second mixin type to collect.</typeparam>
            <typeparam name="TMixin3">The third mixin type to collect.</typeparam>
            <returns>This object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/> for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.EnsureMixin(System.Type)">
            <summary>
            Ensures that the given type is configured as a mixin for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>, adding it if necessary. The mixin will not be
            added if it is also present in the parent context (unless <see cref="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.Clear"/> was called); if added, it will override corresponding
            mixins inherited from a base type.
            </summary>
            <param name="mixinType">The mixin type to collect.</param>
            <returns>This object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/> for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.EnsureMixin``1">
            <summary>
            Ensures that the given type is configured as a mixin for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>, adding it if necessary. The mixin will not be
            added if it is also present in the parent context (unless <see cref="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.Clear"/> was called); if added, it will override corresponding
            mixins inherited from a base type.
            </summary>
            <typeparam name="TMixin">The mixin type to collect.</typeparam>
            <returns>This object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/> for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.EnsureMixins(System.Type[])">
            <summary>
            Ensures that the given types are configured as mixins for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>, adding them if necessary. The mixins will not be
            added if they are also present in the parent context (unless <see cref="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.Clear"/> was called); if added, they will override corresponding
            mixins inherited from a base type.
            </summary>
            <param name="mixinTypes">The mixin types to collect.</param>
            <returns>This object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/> for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.EnsureMixins``2">
            <summary>
            Ensures that the given types are configured as mixins for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>, adding them if necessary. The mixins will not be
            added if they are also present in the parent context (unless <see cref="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.Clear"/> was called); if added, they will override corresponding
            mixins inherited from a base type.
            </summary>
            <typeparam name="TMixin1">The first mixin type to collect.</typeparam>
            <typeparam name="TMixin2">The second mixin type to collect.</typeparam>
            <returns>This object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/> for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.EnsureMixins``3">
            <summary>
            Ensures that the given types are configured as mixins for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>, adding them if necessary. The mixins will not be
            added if they are also present in the parent context (unless <see cref="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.Clear"/> was called); if added, they will override corresponding
            mixins inherited from a base type.
            </summary>
            <typeparam name="TMixin1">The first mixin type to collect.</typeparam>
            <typeparam name="TMixin2">The second mixin type to collect.</typeparam>
            <typeparam name="TMixin3">The third mixin type to collect.</typeparam>
            <returns>This object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/> for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.AddOrderedMixins(System.Type[])">
            <summary>
            Collects the given types as mixins for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/> and adds dependencies between the mixins to ensure a proper base call
            order.
            </summary>
            <param name="mixinTypes">The mixin types to collect with dependencies.</param>
            <returns>This object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/> for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.AddOrderedMixins``2">
            <summary>
            Collects the given types as mixins for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/> and adds dependencies between the mixins to ensure a proper base call
            order.
            </summary>
            <typeparam name="TMixin1">The first mixin type to collect with dependencies.</typeparam>
            <typeparam name="TMixin2">The second mixin type to collect with dependencies.</typeparam>
            <returns>This object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/> for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.AddOrderedMixins``3">
            <summary>
            Collects the given types as mixins for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/> and adds dependencies between the mixins to ensure a proper base call
            order.
            </summary>
            <typeparam name="TMixin1">The first mixin type to collect with dependencies.</typeparam>
            <typeparam name="TMixin2">The second mixin type to collect with dependencies.</typeparam>
            <typeparam name="TMixin3">The third mixin type to collect with dependencies.</typeparam>
            <returns>This object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/> for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.AddCompleteInterface(System.Type)">
            <summary>
            Adds the given type as a complete interface to the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>. A complete interface can contain both members defined by the
            target class itself and by mixins applied to the class, making it easier to invoke methods and properties on a mixed object without casting.
            </summary>
            <param name="interfaceType">The type to collect as a complete interface.</param>
            <returns>This object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/> for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.AddCompleteInterface``1">
            <summary>
            Adds the given type as a complete interface to the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>. A complete interface can contain both members defined by the
            target class itself and by mixins applied to the class, making it easier to invoke methods and properties on a mixed object without casting.
            </summary>
            <typeparam name="TInterface">The type to collect as a complete interface.</typeparam>
            <returns>This object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/> for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.AddCompleteInterfaces(System.Type[])">
            <summary>
            Adds the given types as complete interfaces to the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>. A complete interface can contain both members defined by the
            target class itself and by mixins applied to the class, making it easier to invoke methods and properties on a mixed object without casting.
            </summary>
            <param name="interfaceTypes">The types to collect as complete interfaces.</param>
            <returns>This object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/> for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.AddCompleteInterfaces``2">
            <summary>
            Adds the given types as complete interfaces to the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>. A complete interface can contain both members defined by the
            target class itself and by mixins applied to the class, making it easier to invoke methods and properties on a mixed object without casting.
            </summary>
            <typeparam name="TInterface1">The types to collect as complete interfaces.</typeparam>
            <typeparam name="TInterface2">The types to collect as complete interfaces.</typeparam>
            <returns>This object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/> for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.AddCompleteInterfaces``3">
            <summary>
            Adds the given types as complete interfaces to the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>. A complete interface can contain both members defined by the
            target class itself and by mixins applied to the class, making it easier to invoke methods and properties on a mixed object without casting.
            </summary>
            <typeparam name="TInterface1">The types to collect as complete interfaces.</typeparam>
            <typeparam name="TInterface2">The types to collect as complete interfaces.</typeparam>
            <typeparam name="TInterface3">The types to collect as complete interfaces.</typeparam>
            <returns>This object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/> for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.SuppressMixin(Remotion.Mixins.Context.Suppression.IMixinSuppressionRule)">
            <summary>
            Denotes that specific mixin types should be ignored in the context of this class. Suppression is helpful when a target class should take 
            over most of its mixins from the parent context or inherit mixins from another type, but a specific mixin should be ignored in that process.
            </summary>
            <param name="rule">A <see cref="T:Remotion.Mixins.Context.Suppression.IMixinSuppressionRule"/> denoting mixin types to be suppressed.</param>
            <returns>This object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/> for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.SuppressMixin(System.Type)">
            <summary>
            Denotes that a specific mixin type, and all mixin types that can be ascribed to it (see <see cref="M:Remotion.Utilities.ReflectionUtility.CanAscribe(System.Type,System.Type)"/>), should be
            ignored in the context of this object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/>. Suppression is helpful when a target class should take over most 
            of its mixins from the parent context or inherit mixins from another type, but a specific mixin should be ignored in that 
            process.
            </summary>
            <param name="mixinType">The mixin type, base type, or generic type definition denoting mixin types to be suppressed.</param>
            <returns>This object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/> for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.SuppressMixin``1">
            <summary>
            Denotes that a specific mixin type, and all mixin types that can be ascribed to it (see <see cref="M:Remotion.Utilities.ReflectionUtility.CanAscribe(System.Type,System.Type)"/>), should be
            ignored in the context of this object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/>. Suppression is helpful when a target class should take over most of its mixins from the
            parent context or inherit mixins from another type, but a specific mixin should be ignored in that process.
            </summary>
            <typeparam name="TMixinType">The mixin type, base type, or generic type definition denoting mixin types to be suppressed.</typeparam>
            <returns>This object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/> for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.SuppressMixins(System.Type[])">
            <summary>
            Denotes that a number of mixin types, and all mixin types that can be ascribed to it (see <see cref="M:Remotion.Utilities.ReflectionUtility.CanAscribe(System.Type,System.Type)"/>), should be
            ignored in the context of this object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/>. Suppression is helpful when a target class should take over most of its mixins from the
            parent context or inherit mixins from another type, but a specific mixin should be ignored in that process.
            </summary>
            <param name="mixinTypes">The mixin types, base types, or generic type definitions denoting mixin types to be suppressed.</param>
            <returns>This object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/> for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.SuppressMixins``2">
            <summary>
            Denotes that a number of mixin types, and all mixin types that can be ascribed to it (see <see cref="M:Remotion.Utilities.ReflectionUtility.CanAscribe(System.Type,System.Type)"/>), should be
            ignored in the context of this object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/>. Suppression is helpful when a target class should take over most of its mixins from the
            parent context or inherit mixins from another type, but a specific mixin should be ignored in that process.
            </summary>
            <typeparam name="TMixinType1">The first mixin type, base type, or generic type definition denoting mixin types to be suppressed.</typeparam>
            <typeparam name="TMixinType2">The second mixin type, base type, or generic type definition denoting mixin types to be suppressed.</typeparam>
            <returns>This object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/> for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.SuppressMixins``3">
            <summary>
            Denotes that a number of mixin types, and all mixin types that can be ascribed to it (see <see cref="M:Remotion.Utilities.ReflectionUtility.CanAscribe(System.Type,System.Type)"/>), should be
            ignored in the context of this object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/>. Suppression is helpful when a target class should take over most of its mixins from the
            parent context or inherit mixins from another type, but a specific mixin should be ignored in that process.
            </summary>
            <typeparam name="TMixinType1">The first mixin type, base type, or generic type definition denoting mixin types to be suppressed.</typeparam>
            <typeparam name="TMixinType2">The second mixin type, base type, or generic type definition denoting mixin types to be suppressed.</typeparam>
            <typeparam name="TMixinType3">The third mixin type, base type, or generic type definition denoting mixin types to be suppressed.</typeparam>
            <returns>This object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/> for further configuration of the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.BuildClassContext(System.Collections.Generic.IEnumerable{Remotion.Mixins.Context.ClassContext})">
            <summary>
            Builds a class context with the data collected so far for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/> that inherits from other contexts.
            </summary>
            <param name="inheritedContexts">A collection of <see cref="T:Remotion.Mixins.Context.ClassContext"/> instances the newly built context should inherit mixin data from.</param>
            <returns>A <see cref="T:Remotion.Mixins.Context.ClassContext"/> for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/> holding all mixin configuration data collected so far.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.BuildClassContext">
            <summary>
            Builds a class context with the data collected so far for the <see cref="P:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder.TargetType"/> without inheriting from other contexts.
            </summary>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.ForClass(System.Type)">
            <summary>
            Begins configuration of another target class.
            </summary>
            <param name="targetType">The class to be configured.</param>
            <returns>A fluent interface object for configuring the given <paramref name="targetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.ForClass``1">
            <summary>
            Begins configuration of another target class.
            </summary>
            <typeparam name="TTargetType">The class to be configured.</typeparam>
            <returns>A fluent interface object for configuring the given <typeparamref name="TTargetType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.BuildConfiguration">
            <summary>
            Builds a configuration object with the data gathered so far.
            </summary>
            <returns>A new <see cref="T:Remotion.Mixins.MixinConfiguration"/> instance incorporating all the data acquired so far.</returns>
        </member>
        <member name="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.EnterScope">
            <summary>
            Builds a configuration object and calls the <see cref="M:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.EnterScope"/> method on it, thus activating the configuration for the current
            thread. The previous configuration is restored when the returned object's <see cref="M:System.IDisposable.Dispose"/> method is called (e.g. by a
            using statement).
            </summary>
            <returns>An <see cref="T:System.IDisposable"/> object for restoring the original configuration.</returns>
        </member>
        <member name="P:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.Parent">
            <summary>
            Gets the <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/> used for creating this <see cref="T:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder"/>.
            </summary>
            <value>This object's <see cref="T:Remotion.Mixins.Context.FluentBuilders.ClassContextBuilder"/>.</value>
        </member>
        <member name="P:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.MixinKind">
            <summary>
            Gets the kind of relationship the configured mixin has with its target class.
            </summary>
            <value>The mixin kind.</value>
        </member>
        <member name="P:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.MixinType">
            <summary>
            Gets mixin type configured by this object.
            </summary>
            <value>The mixin type configured by this object.</value>
        </member>
        <member name="P:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.Dependencies">
            <summary>
            Gets the base call dependencies collected so far.
            </summary>
            <value>The base call dependencies collected so far by this object.</value>
        </member>
        <member name="P:Remotion.Mixins.Context.FluentBuilders.MixinContextBuilder.IntroducedMemberVisiblity">
            <summary>
            Gets the default introduced member visiblity for this mixin.
            </summary>
            <value>The default introduced member visiblity.</value>
        </member>
        <member name="T:Remotion.Mixins.Context.MixinContext">
            <summary>
            Represents a single mixin applied to a target class.
            </summary>
            <threadsafety static="true" instance="true"/>
            <remarks>
            Instances of this class are immutable.
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.Context.MixinContext.#ctor(Remotion.Mixins.MixinKind,System.Type,Remotion.Mixins.MemberVisibility,System.Collections.Generic.IEnumerable{System.Type})">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Mixins.Context.MixinContext"/> class.
            </summary>
            <param name="mixinKind">The kind of relationship the configured mixin has with its target class.</param>
            <param name="mixinType">The mixin type represented by this <see cref="T:Remotion.Mixins.Context.MixinContext"/>.</param>
            <param name="introducedMemberVisibility">The default visbility of introduced members.</param>
            <param name="explicitDependencies">The explicit dependencies of the mixin.</param>
        </member>
        <member name="M:Remotion.Mixins.Context.MixinContext.#ctor(Remotion.Mixins.MixinKind,System.Type,Remotion.Mixins.MemberVisibility,System.Type[])">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Mixins.Context.MixinContext"/> class.
            </summary>
            <param name="mixinKind">The kind of mixin represented by this <see cref="T:Remotion.Mixins.Context.MixinContext"/>.</param>
            <param name="mixinType">The mixin type represented by this <see cref="T:Remotion.Mixins.Context.MixinContext"/>.</param>
            <param name="introducedMemberVisibility">The default visbility of introduced members.</param>
            <param name="explicitDependencies">The explicit dependencies of the mixin.</param>
        </member>
        <member name="M:Remotion.Mixins.Context.MixinContext.Equals(System.Object)">
            <summary>
            Determines whether the specified <see cref="T:System.Object"></see> is equal to the current <see cref="T:Remotion.Mixins.Context.MixinContext"/>.
            </summary>
            <param name="obj">The <see cref="T:System.Object"></see> to compare with this <see cref="T:Remotion.Mixins.Context.MixinContext"/>.</param>
            <returns>
            True if the specified <see cref="T:System.Object"></see> is a <see cref="T:Remotion.Mixins.Context.MixinContext"/> for the same mixin type with equal explicit
            dependencies; otherwise, false.
            </returns>
        </member>
        <member name="M:Remotion.Mixins.Context.MixinContext.GetHashCode">
            <summary>
            Returns a hash code for this <see cref="T:Remotion.Mixins.Context.MixinContext"/>.
            </summary>
            <returns>
            A hash code for the current <see cref="T:Remotion.Mixins.Context.MixinContext"/> which includes the hash codes of its mixin type and its explicit dependencies.
            </returns>
        </member>
        <member name="P:Remotion.Mixins.Context.MixinContext.ExplicitDependencies">
            <summary>
            Gets the explicit dependencies added to this <see cref="T:Remotion.Mixins.Context.MixinContext"/>.
            </summary>
            <value>The explicit dependencies added to this <see cref="T:Remotion.Mixins.Context.MixinContext"/>.</value>
            <remarks>An explicit dependency is a base call dependency which should be considered for a mixin even though it is not expressed in the
            mixin's class declaration. This can be used to define the ordering of mixins in specific mixin configurations.</remarks>
        </member>
        <member name="P:Remotion.Mixins.Context.MixinContext.IntroducedMemberVisibility">
            <summary>
            Gets the default visibility of members introduced by this mixin.
            </summary>
            <value>The default introduced member visibility.</value>
        </member>
        <member name="P:Remotion.Mixins.Context.MixinContext.MixinType">
            <summary>
            The mixin type represented by the <see cref="T:Remotion.Mixins.Context.MixinContext"/>.
            </summary>
        </member>
        <member name="P:Remotion.Mixins.Context.MixinContext.MixinKind">
            <summary>
            The kind of relationship the configured mixin has with its target class.
            </summary>
        </member>
        <member name="M:Remotion.Mixins.Context.MixinContextCollection.ContainsAssignableMixin(System.Type)">
            <summary>
            Determines whether this <see cref="T:Remotion.Mixins.Context.ClassContext"/> contains a mixin type assignable to the specified type.
            </summary>
            <param name="baseMixinType">The mixin type to check for.</param>
            <returns>
            True if the <see cref="T:Remotion.Mixins.Context.ClassContext"/> contains a type assignable to the specified type; otherwise, false.
            </returns>
            <exception cref="T:System.ArgumentNullException">The <paramref name="baseMixinType"/> parameter is <see langword="null"/>.</exception>
        </member>
        <member name="M:Remotion.Mixins.Context.MixinContextCollection.ContainsOverrideForMixin(System.Type)">
            <summary>
            Determines whether a mixin configured with this <see cref="T:Remotion.Mixins.Context.ClassContext"/> overrides the given <paramref name="mixinType"/>.
            </summary>
            <param name="mixinType">The mixin type which is to be checked for overriders.</param>
            <returns>
            True if the specified mixin type is overridden in this class context; otherwise, false.
            </returns>
        </member>
        <member name="T:Remotion.Mixins.Context.Suppression.IMixinSuppressionRule">
            <summary>
            Defines a rule suppressing specific mixin types in a mixin configuration.
            </summary>
        </member>
        <member name="M:Remotion.Mixins.Context.Suppression.IMixinSuppressionRule.RemoveAffectedMixins(System.Collections.Generic.Dictionary{System.Type,Remotion.Mixins.Context.MixinContext})">
            <summary>
            Removes all mixins affected by this rule from the <paramref name="configuredMixinTypes"/> dictionary.
            </summary>
            <param name="configuredMixinTypes">The dictionary from which to remove the affected mixins.</param>
        </member>
        <member name="T:Remotion.Mixins.Context.Suppression.MixinTreeReplacementSuppressionRule">
            <summary>
            Replaces all mixins that can be ascribed to a given base class with a new mixin. If the replacing mixin or one of its subclasses can be ascribed
            to the replaced class, it is not suppressed.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.Context.Suppression.MixinTreeSuppressionRule">
            <summary>
            Suppresses all mixins that can be ascribed to a given base class.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.CopyCustomAttributesAttribute">
            <summary>
            When applied to a mixin, specifies a class whose custom attributes should be added to the mixin's target class. This is useful when a mixin
            should add certain attributes without itself exposing those attributes.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.Definitions.Building.DependencySorting.MixinDefinitionSorter">
            <summary>
            Sorts the given mixin definitions by first grouping them into independent groups via <see cref="T:Remotion.Mixins.Definitions.Building.DependencySorting.DependentMixinGrouper"/> and then sorting the
            mixins in the groups via <see cref="T:Remotion.Mixins.Utilities.DependencySort.DependentObjectSorter`1"/>. The groups are alphabetically sorted according to the full name of the first 
            mixin in the group.
            </summary>
        </member>
        <member name="M:Remotion.Mixins.Definitions.Building.DependencySorting.MixinDefinitionSorter.SortMixins(Remotion.Mixins.Definitions.TargetClassDefinition)">
            <summary>
            Sorts the mixins of <paramref name="targetClassDefinition"/>. The <see cref="T:Remotion.Mixins.Definitions.TargetClassDefinition"/> is required because without a target
            class, the dependencies are not defined.
            </summary>
            <param name="targetClassDefinition">The target class definition holding the mixins.</param>
            <returns>A list with the mixins held by <paramref name="targetClassDefinition"/>, but in the correct order.</returns>
        </member>
        <member name="T:Remotion.Mixins.Definitions.Building.MemberOverridePair`1">
            <summary>
            Represents an overridden method together with its overrider.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.Definitions.Building.OverriddenMemberFilter">
            <summary>
            Takes a list of <see cref="T:System.Reflection.MemberInfo"/> objects and removed those members that are overridden within that list, so that only the most derived
            members are returned. For members with more than one accessor (e.g. properties with a get and a set accessor), both overriding and overridden
            member are returned unless all accessors are overridden. This also applies in a chain of overrides - all members are returned that contain one
            accessor that is not overridden.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.Definitions.Building.RequirementsAnalyzer">
            <summary>
            Finds the requirements imposed by a given <see cref="T:Remotion.Mixins.Definitions.MixinDefinition"/> on its <see cref="T:Remotion.Mixins.Definitions.TargetClassDefinition"/> by analyzing the types
            passed as generic arguments of the <see cref="T:Remotion.Mixins.Mixin`1"/> and <see cref="T:Remotion.Mixins.Mixin`2"/> base classes.
            </summary>
            <remarks>
            A <see cref="T:Remotion.Mixins.Definitions.MixinDefinition"/> can either pass an ordinary type (<c>Mixin&lt;IRequirements&gt;</c>) or one of its own generic parameters 
            (<c>Mixin&lt;T&gt;</c>) to its to its <see cref="T:Remotion.Mixins.Mixin`1"/> or <see cref="T:Remotion.Mixins.Mixin`2"/> base classes. This class detects these
            two scenarios and gathers concrete requirement information from either the type itself or its generic parameter constraints.
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.Definitions.Building.RequirementsAnalyzer.#ctor(Remotion.Mixins.Utilities.MixinGenericArgumentFinder)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Mixins.Definitions.Building.RequirementsAnalyzer"/> class.
            </summary>
            <param name="genericArgumentFinder">The <see cref="T:Remotion.Mixins.Utilities.MixinGenericArgumentFinder"/> used to determine the generic argument defining the
            requirements to be analyzed.</param>
        </member>
        <member name="M:Remotion.Mixins.Definitions.ClassDefinitionBase.GetAdjustedInterfaceMap(System.Type)">
            <summary>
            Gets the result of <see cref="M:System.Type.GetInterfaceMap(System.Type)"/> for <see cref="P:Remotion.Mixins.Definitions.ClassDefinitionBase.Type"/>, adjusting the <see cref="T:System.Reflection.MethodInfo"/> instances returned
            so that they match those stored in the <see cref="T:Remotion.Mixins.Definitions.MethodDefinition"/> objects freturned by <see cref="P:Remotion.Mixins.Definitions.ClassDefinitionBase.Methods"/> and <see cref="M:Remotion.Mixins.Definitions.ClassDefinitionBase.GetAllMembers"/>.
            </summary>
            <param name="interfaceType">The interface to create a mapping for.</param>
            <remarks>When calling <see cref="M:System.Type.GetInterfaceMap(System.Type)"/>, the <see cref="P:System.Reflection.MemberInfo.ReflectedType"/> properties of the returned 
            <see cref="T:System.Reflection.MethodInfo"/> objects do not match those of the <see cref="T:System.Reflection.MethodInfo"/> objects stored by this <see cref="T:Remotion.Mixins.Definitions.ClassDefinitionBase"/>.
            This method remedies this by aligning the returned <see cref="T:System.Reflection.MethodInfo"/> instances with the stored ones.</remarks>
        </member>
        <member name="T:Remotion.Mixins.Definitions.TargetClassDefinitionFactory">
            <summary>
            Creates <see cref="T:Remotion.Mixins.Definitions.TargetClassDefinition"/> objects from <see cref="T:Remotion.Mixins.Context.ClassContext"/> instances, validating them before returning.
            </summary>
            <remarks>
            This class acts as a facade for <see cref="T:Remotion.Mixins.Definitions.Building.TargetClassDefinitionBuilder"/> and <see cref="T:Remotion.Mixins.Validation.Validator"/>.
            </remarks>
        </member>
        <member name="T:Remotion.Mixins.ExtendsAttribute">
            <summary>
            Indicates that a mixin extends a specific class, providing some part of its functionality or public interface.
            </summary>
            <remarks>
            <para>
            This attribute is effective for the declarative mixin configuration, which is in effect by default when an application is started.
            </para>
            <para> 
            Although the attribute itself is not inherited, its semantics in mixin configuration are: If a base class is configured to be mixed with a
            mixin type M by means of the <see cref="T:Remotion.Mixins.ExtendsAttribute"/>, this configuration setting is inherited by each of its (direct and indirect) subclasses.
            The subclasses will therefore also be mixed with the same mixin type M unless a second mixin M2 derived from M is applied to the subclass, thus
            overriding the inherited configuration. If M is configured for both base class and subclass, the base class configuration is ignored.
            </para>
            <para>
            This attribute can be applied to the same mixin class multiple times if it extends multiple target classes. It should not however be used to
            apply the same mixin multiple times to the same target class.
            </para>
            </remarks>
        </member>
        <member name="T:Remotion.Mixins.MixinRelationshipAttribute">
            <summary>
            Acts as a common base class for attributes used in declaratively specifying the mixin configuration by expressing the relationship between a
            mixin and its target class, eg. <see cref="T:Remotion.Mixins.ExtendsAttribute"/>, <see cref="T:Remotion.Mixins.UsesAttribute"/>, <see cref="T:Remotion.Mixins.MixAttribute"/>
            </summary>
        </member>
        <member name="P:Remotion.Mixins.MixinRelationshipAttribute.AdditionalDependencies">
            <summary>
            Gets or sets additional explicit base call dependencies for the applied mixin type. This can be used to establish an ordering when
            combining unrelated mixins on a class which override the same methods.
            </summary>
            <value>The additional dependencies of the mixin. The validity of the dependency types is not checked until the configuration is built.</value>
            <exception cref="T:System.ArgumentNullException">The <paramref name="value"/> argument is <see langword="null"/>.</exception>
        </member>
        <member name="P:Remotion.Mixins.MixinRelationshipAttribute.SuppressedMixins">
            <summary>
            Gets or sets the mixins suppressed by the applied mixin.
            </summary>
            <value>The mixins suppressed by the applied mixins.</value>
            <remarks>Use this attribute to actively remove a mixin from the attribute's target type. The list of suppressed mixins cannot contain 
            the applied mixin itself, but it can contain mixins which themselves suppress this mixin. Such circular suppressions result in both mixins
            being removed from the configuration.</remarks>
        </member>
        <member name="P:Remotion.Mixins.MixinRelationshipAttribute.IntroducedMemberVisibility">
            <summary>
            Gets or sets the default visibility of members introduced by the mixin to the target class. The default is <see cref="F:Remotion.Mixins.MemberVisibility.Private"/>.
            </summary>
            <value>The introduced member visibility.</value>
        </member>
        <member name="M:Remotion.Mixins.ExtendsAttribute.#ctor(System.Type)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Mixins.ExtendsAttribute"/> class.
            </summary>
            <param name="targetType">The target type extended by this mixin.</param>
        </member>
        <member name="P:Remotion.Mixins.ExtendsAttribute.TargetType">
            <summary>
            Gets the target type the mixin class applies to.
            </summary>
            <value>The target type the mixin class applies to.</value>
        </member>
        <member name="P:Remotion.Mixins.ExtendsAttribute.MixinTypeArguments">
            <summary>
            Gets or sets the generic type arguments to be used when applying a generic mixin to the given target type. This is useful when the
            <see cref="T:Remotion.Mixins.ExtendsAttribute"/> is to be applied to a generic mixin class, but the default generic type specialization algorithm of the
            mixin engine does not give the desired results.
            </summary>
            <value>The generic type arguments to close the generic mixin type with.</value>
            <remarks>If this attribute is applied to a non-generic mixin class or if the types supplied don't match the mixin's generic parameters,
            an exception is thrown when the mixin configuration is analyzed.</remarks>
        </member>
        <member name="T:Remotion.Mixins.GenerationPolicy">
            <summary>
            Defines how the <see cref="T:Remotion.Mixins.TypeFactory"/> and <see cref="T:Remotion.Mixins.ObjectFactory"/> behave when asked to generate a concrete type for a target
            type without any mixin configuration information.
            </summary>
        </member>
        <member name="F:Remotion.Mixins.GenerationPolicy.ForceGeneration">
            <summary>
            Specifies that <see cref="T:Remotion.Mixins.TypeFactory"/> and <see cref="T:Remotion.Mixins.ObjectFactory"/> should always generate concrete types, no matter whether
            mixin configuration information exists for the given target type or not.
            </summary>
        </member>
        <member name="F:Remotion.Mixins.GenerationPolicy.GenerateOnlyIfConfigured">
            <summary>
            Specifies that <see cref="T:Remotion.Mixins.TypeFactory"/> and <see cref="T:Remotion.Mixins.ObjectFactory"/> should only generate concrete types if
            mixin configuration information exists for the given target type.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.Globalization.MixedMultiLingualResources">
            <summary>
            Provides a variant of <see cref="T:Remotion.Globalization.MultiLingualResources"/> that can be used to have mixins add resource identifiers to a target
            class. With this class, attributes are not only retrieved from the class and its base classes, but also from its mixins.
            </summary>
            <remarks>
            The methods of this class do not have overloads taking object - getting and checking resources is always done via the type.
            The reason for this is as follows: If an instance was specified, its type would have to be used. Now, if the instance was not created 
            by the <see cref="T:Remotion.Mixins.ObjectFactory"/>, we would have to either:
            <list type="bullet">
              <item>Fall back to <see cref="T:Remotion.Globalization.MultiLingualResources"/>, because the "new-ed" object doesn't have any mixins, so the type-based resource 
              lookup shouldn't use the mixins either; or </item>
              <item>Be consistent with ExistsResource (obj.GetType()), ie. considering the mixins as well.</item>
            </list>
            Both possibilities have a certain inconsistency, and none is perfect, so the class leaves it to the user to decide.
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.Globalization.MixedMultiLingualResources.GetResourceManager(System.Type,System.Boolean)">
            <summary>
              Returns an instance of <see cref="T:Remotion.Globalization.IResourceManager"/> for the resource container specified in the class declaration of the type.
            </summary>
            <param name="objectType">The type to return an <see cref="T:Remotion.Globalization.IResourceManager"/> for.</param>
            <param name="includeHierarchy">If set to true, <see cref="T:Remotion.Globalization.MultiLingualResourcesAttribute"/> applied to base classes and mixins will be
            included in the resource manager; otherwise, only the <paramref name="objectType"/> is searched for such attributes.</param>
            <returns>An instance of <see cref="T:Remotion.Globalization.IResourceManager"/> for <paramref name="objectType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Globalization.MixedMultiLingualResources.GetResourceManager(System.Type)">
            <summary>
              Returns an instance of <see cref="T:Remotion.Globalization.IResourceManager"/> for the resource container specified in the class declaration of the type
              that does not include resource managers for base classes and mixins.
            </summary>
            <param name="objectType">The type to return an <see cref="T:Remotion.Globalization.IResourceManager"/> for.</param>
            <returns>An instance of <see cref="T:Remotion.Globalization.IResourceManager"/> for <paramref name="objectType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.Globalization.MixedMultiLingualResources.GetResourceText(System.Type,System.String)">
            <summary>
              Loads a string resource for the specified type, identified by ID.
            </summary>
            <param name="objectTypeToGetResourceFor">
              The <see cref="T:System.Type"/> for which to get the resource.
            </param>
            <param name="name"> The ID of the resource. </param>
            <returns> The found string resource or an empty string. </returns>
        </member>
        <member name="M:Remotion.Mixins.Globalization.MixedMultiLingualResources.ExistsResourceText(System.Type,System.String)">
            <summary>
              Checks for the existence of a string resource for the specified type, identified by ID.
            </summary>
            <param name="objectTypeToGetResourceFor">
              The <see cref="T:System.Type"/> for which to check the resource.
            </param>
            <param name="name"> The ID of the resource. </param>
            <returns> <see langword="true"/> if the resource can be found. </returns>
        </member>
        <member name="M:Remotion.Mixins.Globalization.MixedMultiLingualResources.ExistsResource(System.Type)">
            <summary>
              Checks for the existence of a resource set for the specified type.
            </summary>
            <param name="objectTypeToGetResourceFor">
              The <see cref="T:System.Type"/> for which to check for the resource set.
            </param>
            <returns> <see langword="true"/> if the resource set can be found. </returns>
        </member>
        <member name="P:Remotion.Mixins.Globalization.MixedMultiLingualResources.Resolver">
            <summary>
            Gets the resolver object used by the methods of this class.
            </summary>
            <value>The resolver object used by <see cref="T:Remotion.Globalization.MultiLingualResources"/>.</value>
        </member>
        <member name="T:Remotion.Mixins.Globalization.MixedResourceManagerResolver`1">
            <summary>
            Extends <see cref="T:Remotion.Globalization.ResourceManagerResolver`1"/> to detect resources added via mixins.
            </summary>
            <typeparam name="TAttribute">The type of the resource attribute to be resolved by this class.</typeparam>
        </member>
        <member name="T:Remotion.Mixins.IgnoreForMixinConfigurationAttribute">
            <summary>
            Causes the mixin engine to ignore all mixin configuration attributes on the type this attribute is applied to when building the default
            mixin configuration.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.IgnoresClassAttribute">
            <summary>
            Defines that a mixin is not applied to a specific class, even when it is explicitly or implicitly configured for that class via
            the declarative configuration attributes <see cref="T:Remotion.Mixins.UsesAttribute"/>, <see cref="T:Remotion.Mixins.ExtendsAttribute"/>, and <see cref="T:Remotion.Mixins.MixAttribute"/>.
            </summary>
            <remarks>
            <para>
            Use this attribute to exclude a target class inherited from a mixin's base class. This attribute is not inherited, so the target class
            exclusion will only work for the exact mixin to which the attribute is applied.
            </para>
            <para>
            Note that when a mixin excludes a generic type definition (e.g. <c>C&lt;&gt;</c>), a corresponding closed generic type (<c>C&lt;int&gt;</c>) can
            still inherit the mixin from its base class. This is by design due to the rule that a closed generic type inherits mixins from both 
            its base class and its generic type definition.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.IgnoresClassAttribute.#ctor(System.Type)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Mixins.IgnoresClassAttribute"/> class, specifying the class to be ignored by this mixin.
            </summary>
            <param name="classToIgnore">The class to be ignored in declarative configuration. Subclasses of this class
            will not inherit the mixin either.</param>
        </member>
        <member name="P:Remotion.Mixins.IgnoresClassAttribute.ClassToIgnore">
            <summary>
            Gets the class to be ignored by this mixin.
            </summary>
            <value>The class to be ignored.</value>
        </member>
        <member name="T:Remotion.Mixins.IgnoresMixinAttribute">
            <summary>
            Defines that a specific mixin is not applied to a class, even when it is explicitly or implicitly configured for that class via
            the declarative configuration attributes <see cref="T:Remotion.Mixins.UsesAttribute"/>, <see cref="T:Remotion.Mixins.ExtendsAttribute"/>, and <see cref="T:Remotion.Mixins.MixAttribute"/>.
            </summary>
            <remarks>
            <para>
            Use this attribute to exclude a mixin that is configured to be applied to a base class. This attribute is not inherited, so the mixin
            exclusion will only work for the exact mixin to which the attribute is applied.
            </para>
            <para>
            Note that when a generic type definition (e.g. <c>C&lt;&gt;</c>) excludes a mixin, a corresponding closed generic class (<c>C&lt;int&gt;</c>) can
            still inherit the mixin from its base class. This is by design due to the rule that a closed generic type inherits mixins from both 
            its base class and its generic type definition.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.IgnoresMixinAttribute.#ctor(System.Type)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Mixins.IgnoresClassAttribute"/> class, specifying the mixin to be ignored by this class.
            </summary>
            <param name="mixinToIgnore">The mixin to be ignored in declarative configuration. Subclasses of this class will not inherit the mixin either.</param>
        </member>
        <member name="P:Remotion.Mixins.IgnoresMixinAttribute.MixinToIgnore">
            <summary>
            Gets the mixin to be ignored by this class.
            </summary>
            <value>The mixin to be ignored.</value>
        </member>
        <member name="T:Remotion.Mixins.IInitializableMixin">
            <summary>
            Denotes a mixin that can be initialized. This interface is used by the infrastructure and should not be applied by user code.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.IOverrideAttribute">
            <summary>
            Common interface for attributes specifying member overrides. This interface is used by the infrastructure and should not be applied by user code.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.MemberVisibility">
            <summary>
            Defines the visibility of members generated by the mixin infrastructure.
            </summary>
        </member>
        <member name="F:Remotion.Mixins.MemberVisibility.Private">
            <summary>
            The members are generated private.
            </summary>
        </member>
        <member name="F:Remotion.Mixins.MemberVisibility.Public">
            <summary>
            The members are generated public.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.MemberVisibilityAttribute">
            <summary>
            When applied to an interface member, defines the visibility of that member when it is introduced into a mixed type. This overrides the value
            specified via <see cref="P:Remotion.Mixins.MixinRelationshipAttribute.IntroducedMemberVisibility"/>.
            </summary>
        </member>
        <member name="M:Remotion.Mixins.MemberVisibilityAttribute.#ctor(Remotion.Mixins.MemberVisibility)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Mixins.MemberVisibilityAttribute"/> class.
            </summary>
            <param name="visibility">The visibility to be used for the attributed member.</param>
        </member>
        <member name="P:Remotion.Mixins.MemberVisibilityAttribute.Visibility">
            <summary>
            Gets the visibility set to be used for the attributed member.
            </summary>
            <value>The visibility to be used.</value>
        </member>
        <member name="T:Remotion.Mixins.MixAttribute">
            <summary>
            Configures that a class and a mixin should be mixed together.
            </summary>
            <remarks>
            <para>
            This attribute is effective for the declarative mixin configuration, which is in effect by default when an application is started.
            </para>
            <para> 
            The <see cref="T:Remotion.Mixins.MixAttribute"/> is an alternative to <see cref="T:Remotion.Mixins.UsesAttribute"/> and <see cref="T:Remotion.Mixins.ExtendsAttribute"/> allowing assembly-level mixin
            configuration. Therefore, it is suitable for transparently putting mixins and classes together, with neither mixin nor target class explicitly
            referencing the other side of the relationship.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.MixAttribute.#ctor(System.Type,System.Type)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Mixins.MixAttribute"/> class.
            </summary>
            <param name="targetType">The target type to be mixed.</param>
            <param name="mixinType">The mixin type to be mixed with the target type.</param>
        </member>
        <member name="P:Remotion.Mixins.MixAttribute.MixinKind">
            <summary>
            Gets or sets the kind of relationship between the mixin and its target class. For more information see <see cref="T:Remotion.Mixins.MixinKind"/>. If not
            explicitly specified, <see cref="F:Remotion.Mixins.MixinKind.Extending"/> is assumed.
            </summary>
            <value>The mixin kind.</value>
        </member>
        <member name="P:Remotion.Mixins.MixAttribute.TargetType">
            <summary>
            Gets the target type to be mixed.
            </summary>
            <value>The mixed type.</value>
        </member>
        <member name="P:Remotion.Mixins.MixAttribute.MixinType">
            <summary>
            Gets the mixin type mixed with the target class.
            </summary>
            <value>The mixin type.</value>
        </member>
        <member name="T:Remotion.Mixins.MixerTools.Mixer">
            <summary>
            Provides functionality for pre-generating mixed types and saving them to disk to be later loaded via 
            <see cref="M:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder.LoadConcreteTypes(System.Reflection.Assembly)"/>.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.Mixin">
            <summary>
            Provides reflective access to the mixins integrated with a target class.
            </summary>
        </member>
        <member name="M:Remotion.Mixins.Mixin.Get``1(System.Object)">
            <summary>
            Gets the instance of the specified mixin type <typeparamref name="TMixin"/> that was mixed into the given <paramref name="mixinTarget"/>.
            </summary>
            <typeparam name="TMixin">The mixin type to get an instance of.</typeparam>
            <param name="mixinTarget">The mixin target to get the mixin instance from.</param>
            <returns>The instance of the specified mixin type that was mixed into the given mixin target, or <see langword="null"/> if the target does not
            include a mixin of that type.</returns>
            <exception cref="T:System.ArgumentNullException">The <paramref name="mixinTarget"/> parameter is <see langword="null"/>.</exception>
            <remarks>
            This method cannot be used with mixins that have been configured as open generic type definitions. Use the <see cref="M:Remotion.Mixins.Mixin.Get(System.Type,System.Object)">
            non-generic</see> variant instead.
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.Mixin.Get(System.Type,System.Object)">
            <summary>
            Gets the instance of the specified <paramref name="mixinType"/> that was mixed into the given <paramref name="mixinTarget"/>.
            </summary>
            <param name="mixinType">The mixin type to get an instance of.</param>
            <param name="mixinTarget">The mixin target to get the mixin instance from.</param>
            <returns>The instance of the specified mixin type that was mixed into the given mixin target, or <see langword="null"/> if the target does not
            include a mixin of that type.</returns>
            <exception cref="T:System.ArgumentNullException">The <paramref name="mixinType"/> or the <paramref name="mixinTarget"/> parameter is
            <see langword="null"/>.</exception>
            <remarks>
            This method can also be used with mixins that have been configured as open generic type definitions. Use the open generic type definition
            to retrieve them, but be prepared to get an instance of a specialized (closed) generic type back.
            </remarks>
        </member>
        <member name="T:Remotion.Mixins.Mixin`2">
            <summary>
            Acts as a base class for mixins that require a reference to their target object (<see cref="P:Remotion.Mixins.Mixin`1.Target"/>) and a reference for calling 
            the base implementations of overridden methods (<see cref="P:Remotion.Mixins.Mixin`2.Next"/>).
            </summary>
            <typeparam name="TTarget">The minimum type required for calling methods on the target object (<see cref="P:Remotion.Mixins.Mixin`1.Target"/>). The
            mixin can only be applied to types that fulfill this type constraint either themselves or via other mixins.
            This type needn't actually be implemented by the target class. See Remarks section for details.
            </typeparam>
            <typeparam name="TNext">The minimum type required for making base calls (<see cref="P:Remotion.Mixins.Mixin`2.Next"/>) when overriding a method of the target class. 
            This type needn't actually be implemented by the target class. See Remarks section for details.</typeparam>
            <remarks>
            <para>
            Typically, this base class will be used whenever a mixin overrides a method of a target class and it needs to call the overridden base implementation.
            Derive from the <see cref="T:Remotion.Mixins.Mixin`1"/> class if you only need the target object reference but are not making any base calls, or use any
            base class if not even the target object reference is required.
            </para>
            <para>
            <typeparamref name="TTarget"/> is called the target-call dependency of the mixin, and can be assigned a class or interface (or a type parameter with 
            class or interface constraints). It defines the type of the <see cref="P:Remotion.Mixins.Mixin`1.Target"/> property, which is used to access the target
            instance of this mixin as well as members of other mixins applied to the same target instance. The mixin engine will ensure that 
            the target-call dependency is fulfilled either by the target class of the mixin, or by any mixin applied to the target class. 
            Accessing a member via the <see cref="P:Remotion.Mixins.Mixin`1.Target"/> property will actually access the corresponding member of the implementing target 
            class or mixin.
            </para>
            <para>
            <typeparamref name="TNext"/> is called the next-call dependency of the mixin and can be assigned an interface or
            the type <see cref="T:System.Object"/> (or a type parameter with interface or <see cref="T:System.Object"/> constraints). It defines the type
            of the <see cref="P:Remotion.Mixins.Mixin`2.Next"/> property, which is used when a mixin overrides a member of the target class and needs to call the next implementation 
            in the chain of overrides (or the base implementation on the target class, when there is no other mixin in the chain).
            The next-call dependencies of a mixin also define the order in which method overrides are executed when multiple mixins override the same target 
            method: when mixin A has a next-call dependency on an interface IB, its override will be executed before any mixin implementing the interface IB.
            </para>
            <para>If <typeparamref name="TTarget"/> or <typeparamref name="TNext"/> are interfaces, that dependency need not actually be implemented on the 
            target class as an interface is usually implemented. There are two additional possibilities:
            <list type="bullet">
            <item>
            The interface can be implemented on a mixin applied to the same target class.
            </item>
            <item>
            The members of the interface can be implemented on the target class with the same name and signature as defined by the interface (duck typing).
            </item>
            </list>
            The latter enables a mixin to define its dependencies even if the target class and any interfaces it implements are unknown.
            </para>
            <para>
            If a concrete mixin derived from this class is a generic type, it can be configured as a mixin in its open generic type definition form 
            (<c>typeof (C&lt;,&gt;)</c>). In such a case, the mixin engine will try to close it at the time of configuration analysis; for this, 
            binding information in the form of the <see cref="T:Remotion.Mixins.BindToTargetTypeAttribute"/>, <see cref="T:Remotion.Mixins.BindToConstraintsAttribute"/>, and 
            <see cref="T:Remotion.Mixins.BindToGenericTargetParameterAttribute"/> is used.
            </para>
            </remarks>
        </member>
        <member name="T:Remotion.Mixins.Mixin`1">
            <summary>
            Acts as a base class for mixins that require a reference to their target object (<see cref="P:Remotion.Mixins.Mixin`1.Target"/>).
            </summary>
            <typeparam name="TTarget">The minimum type required for calling methods on the target object (<see cref="P:Remotion.Mixins.Mixin`1.Target"/>). The
            mixin can only be applied to types that fulfill this type constraint either themselves or via other mixins.
            This type needn't actually be implemented by the target class. See Remarks section for details.
            </typeparam>
            <remarks>
            <para>
            Typically, this base class will be used for those mixins which do require a reference to their target object, but which do not overrride
            any methods. 
            Derive from the <see cref="T:Remotion.Mixins.Mixin`2"/> class if you need to override target methods, or use any
            base class if not even the target object reference is required.
            </para>
            <para>
            <typeparamref name="TTarget"/> is called the target-call dependency of the mixin, and can be assigned a class or interface (or a type parameter with 
            class or interface constraints). It defines the type of the <see cref="P:Remotion.Mixins.Mixin`1.Target"/> property, which is used to access the target
            instance of this mixin as well as members of other mixins applied to the same target instance. The mixin engine will ensure that 
            the target-call dependency is fulfilled either by the target class of the mixin, or by any mixin applied to the target class. 
            Accessing a member via the <see cref="P:Remotion.Mixins.Mixin`1.Target"/> property will actually access the corresponding member of the implementing target 
            class or mixin.
            </para>
            <para>
            If <typeparamref name="TTarget"/> is an interface, that dependency need not actually be implemented on the 
            target class as an interface is usually implemented. There are two additional possibilities:
            <list type="bullet">
            <item>
            The interface can be implemented on a mixin applied to the same target class.
            </item>
            <item>
            The members of the interface can be implemented on the target class with the same name and signature as defined by the interface (duck typing).
            </item>
            </list>
            The latter enables a mixin to define its dependencies even if the target class and any interfaces it implements are unknown.
            </para>
            <para>
            If a concrete mixin derived from this class is a generic type, it can be configured as a mixin in its open generic type definition form 
            (<c>typeof (C&lt;&gt;)</c>). In such a case, the mixin engine will try to close it at the time of configuration analysis; for this, 
            binding information in the form of the <see cref="T:Remotion.Mixins.BindToTargetTypeAttribute"/>, <see cref="T:Remotion.Mixins.BindToConstraintsAttribute"/>, and 
            <see cref="T:Remotion.Mixins.BindToGenericTargetParameterAttribute"/> is used.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.Mixin`1.OnInitialized">
            <summary>
            Called when the mixin has been initialized and its properties can be safely accessed.
            </summary>
        </member>
        <member name="M:Remotion.Mixins.Mixin`1.OnDeserialized">
            <summary>
            Called when the mixin has been deserialized and its properties can be safely accessed.
            </summary>
        </member>
        <member name="P:Remotion.Mixins.Mixin`1.Target">
            <summary>
            Gets a reference to the concrete mixed object.
            </summary>
            <value>The target object reference.</value>
            <exception cref="T:System.InvalidOperationException">The mixin has not been initialized yet, probably because the property is accessed from the mixin's
            constructor.</exception>
            <remarks>
            This property must not be accessed from the mixin's constructor; if you need to initialize the mixin by accessing the <see cref="P:Remotion.Mixins.Mixin`1.Target"/>
            property, override the <see cref="M:Remotion.Mixins.Mixin`1.OnInitialized"/> method.
            <note type="warning">
            Be careful when calling members that this mixin overrides via the <see cref="P:Remotion.Mixins.Mixin`1.Target"/> property, this can easily throw a
            <see cref="T:System.StackOverflowException"/> because the <see cref="P:Remotion.Mixins.Mixin`1.Target"/> property includes all mixins defined on the target object. Use 
            <see cref="P:Remotion.Mixins.Mixin`2.Next"/> instead to call the base implementations of overridden members.
            </note>
            </remarks>
        </member>
        <member name="P:Remotion.Mixins.Mixin`2.Next">
            <summary>
            Provides a way to call the next or base implementation from member overrides.
            </summary>
            <value>The next implementation to be called.</value>
            <exception cref="T:System.InvalidOperationException">The mixin has not been initialized yet, probably because the property is accessed from the mixin's
            constructor.</exception>
            <remarks>
            <para>
            This property must not be accessed from the mixin's constructor; if you need to initialize the mixin by accessing the <see cref="P:Remotion.Mixins.Mixin`2.Next"/>
            property (which is unusual because the <see cref="P:Remotion.Mixins.Mixin`2.Next"/> property should only be used from member overrides), override the 
            <see cref="M:Remotion.Mixins.Mixin`1.OnInitialized"/> method.
            </para>
            <para>
            This property is only for calling the next implementation from overridden methods. It should not be used to access arbitrary methods of the 
            mixin's target object, use the <see cref="P:Remotion.Mixins.Mixin`1.Target"/> property instead. If the <see cref="P:Remotion.Mixins.Mixin`2.Next"/> property is used other than to 
            perform base calls from member overrides and more than one mixin is applied to the target object, unexpected behavior may arise because the 
            <see cref="P:Remotion.Mixins.Mixin`2.Next"/> property will represent the target object together with a subset (but not all) of its mixins.
            </para>
            <para>
            When a member is accessed via the <see cref="P:Remotion.Mixins.Mixin`2.Next"/> property, the member is actually called on either the next mixin in the override chain
            for the corresponding member, or on the target class if there are no more mixins in the chain. The order in which member overrides are
            chained is defined by mixin ordering, e.g. via the dependencies expressed via the <typeparamref name="TNext"/> parameter.
            </para>
            </remarks>
        </member>
        <member name="T:Remotion.Mixins.MixinConfiguration">
            <summary>
            Constitutes a mixin configuration (ie. a set of classes associated with mixins) and manages the mixin configuration for the current thread
            (actually: <see cref="T:Remotion.Context.SafeContext"/>). 
            Instances of this class are immutable, i.e., their content is initialized on construction and cannot be changed later on.
            </summary>
            <remarks>
            <para>
            Instances of this class represent a single mixin configuration, ie. a set of classes associated with mixins. The class manages a thread-local
            (actually <see cref="T:Remotion.Context.SafeContext"/>-local) single active configuration instance via its <see cref="P:Remotion.Mixins.MixinConfiguration.ActiveConfiguration"/> property and
            related methods; the active configuration can conveniently be replaced via the <see cref="M:Remotion.Mixins.MixinConfiguration.EnterScope"/> method.
            </para>
            <para>
            <see cref="T:Remotion.Mixins.MixinConfiguration"/> also provides entry points for building new mixin configuration objects: <see cref="M:Remotion.Mixins.MixinConfiguration.BuildNew"/>, 
            <see cref="M:Remotion.Mixins.MixinConfiguration.BuildFromActive"/>, and <see cref="M:Remotion.Mixins.MixinConfiguration.BuildFrom(Remotion.Mixins.MixinConfiguration)"/>.
            </para>
            <para>
            While the <see cref="P:Remotion.Mixins.MixinConfiguration.ActiveConfiguration"/> will usually be accessed only indirectly via <see cref="T:Remotion.Mixins.ObjectFactory"/> or 
            <see cref="T:Remotion.Mixins.TypeFactory"/>, <see cref="M:Remotion.Mixins.MixinConfiguration.EnterScope"/> and the <see cref="M:Remotion.Mixins.MixinConfiguration.BuildFromActive">BuildFrom...</see> methods can be very useful to adjust 
            a thread's mixin configuration at runtime.
            </para>
            <para>
            The master mixin configuration - the default configuration in effect for a thread if not specifically replaced by another configuration - is 
            obtained by analyzing the assemblies in the application's bin directory for attributes such as <see cref="T:Remotion.Mixins.UsesAttribute"/>,
            <see cref="T:Remotion.Mixins.ExtendsAttribute"/>, and <see cref="T:Remotion.Mixins.CompleteInterfaceAttribute"/>. (For more information about the default configuration, see
            <see cref="M:Remotion.Mixins.Context.DeclarativeConfigurationBuilder.BuildDefaultConfiguration"/>.) The master configuration can be accessed via 
            <see cref="M:Remotion.Mixins.MixinConfiguration.GetMasterConfiguration"/> and <see cref="M:Remotion.Mixins.MixinConfiguration.SetMasterConfiguration(Remotion.Mixins.MixinConfiguration)"/>.
            </para>
            <example>
            The following shows an exemplary application of the <see cref="T:Remotion.Mixins.MixinConfiguration"/> class that manually builds mixin configuration instances
            and activates them for the current thread for a given scope.
            <code>
            class Program
            {
              public static void Main()
              {
                // myType1 is an instantiation of MyType with the default mixin configuration
                MyType myType1 = ObjectFactory.Create&lt;MyType&gt; ().With();
            
                using (MixinConfiguration.BuildNew().ForClass&lt;MyType&gt;.AddMixin&lt;SpecialMixin&gt;().EnterScope())
                {
                  // myType2 is an instantiation of MyType with a specific configuration, which contains only SpecialMixin
                  MyType myType2 = ObjectFactory.Create&lt;MyType&gt; ().With();
            
                  using (MixinConfiguration.BuildNew().EnterScope())
                  {
                    // myType3 is an instantiation of MyType without any mixins
                    MyType myType3 = ObjectFactory.Create&lt;MyType&gt; ().With();
                  }
                }
            
                // myType4 again is an instantiation of MyType with the default mixin configuration
                MyType myType4 = ObjectFactory.Create&lt;MyType&gt; ().With();
              }
            }
            </code>
            </example>
            </remarks>
            <threadsafety static="true" instance="true"/>
        </member>
        <member name="M:Remotion.Mixins.MixinConfiguration.SetActiveConfiguration(Remotion.Mixins.MixinConfiguration)">
            <summary>
            Sets the active mixin configuration configuration for the current thread.
            </summary>
            <param name="configuration">The configuration to be set, can be <see langword="null"/>.</param>
        </member>
        <member name="M:Remotion.Mixins.MixinConfiguration.BuildNew">
            <summary>
            Returns a <see cref="T:Remotion.Mixins.Context.FluentBuilders.MixinConfigurationBuilder"/> object to build a new <see cref="T:Remotion.Mixins.MixinConfiguration"/>.
            </summary>
            <returns>A <see cref="T:Remotion.Mixins.Context.FluentBuilders.MixinConfigurationBuilder"/> for building a new <see cref="T:Remotion.Mixins.MixinConfiguration"/> with a fluent interface.</returns>
            <remarks>
            <para>
            Use this method to build a new <see cref="T:Remotion.Mixins.MixinConfiguration"/> from scratch.
            </para>
            <para>
            If you want to temporarily make the built
            <see cref="T:Remotion.Mixins.MixinConfiguration"/> the <see cref="P:Remotion.Mixins.MixinConfiguration.ActiveConfiguration"/>, call the builder's <see cref="M:Remotion.Mixins.Context.FluentBuilders.MixinConfigurationBuilder.EnterScope"/>
            method from within a <c>using</c> statement.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.MixinConfiguration.BuildFrom(Remotion.Mixins.MixinConfiguration)">
            <summary>
            Returns a <see cref="T:Remotion.Mixins.Context.FluentBuilders.MixinConfigurationBuilder"/> object to build a new <see cref="T:Remotion.Mixins.MixinConfiguration"/> which inherits data from a 
            <paramref name="parentConfiguration"/>. This method indirectly creates a copy of the <paramref name="parentConfiguration"/>. Use 
            <see cref="M:Remotion.Mixins.MixinConfiguration.BuildNew"/> to avoid the costs of copying.
            </summary>
            <param name="parentConfiguration">A <see cref="T:Remotion.Mixins.MixinConfiguration"/> whose data should be inherited from the built
            <see cref="T:Remotion.Mixins.MixinConfiguration"/>.</param>
            <returns>A <see cref="T:Remotion.Mixins.Context.FluentBuilders.MixinConfigurationBuilder"/> for building a new <see cref="T:Remotion.Mixins.MixinConfiguration"/> with a fluent interface.</returns>
            <remarks>
            <para>
            Use this method to build a new <see cref="T:Remotion.Mixins.MixinConfiguration"/> while taking over the class-mixin bindings from an existing
            <see cref="T:Remotion.Mixins.MixinConfiguration"/> object.
            </para>
            <para>
            If you want to temporarily make the built
            <see cref="T:Remotion.Mixins.MixinConfiguration"/> the <see cref="P:Remotion.Mixins.MixinConfiguration.ActiveConfiguration"/>, call the builder's <see cref="M:Remotion.Mixins.Context.FluentBuilders.MixinConfigurationBuilder.EnterScope"/>
            method from within a <c>using</c> statement.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.MixinConfiguration.BuildFromActive">
            <summary>
            Returns a <see cref="T:Remotion.Mixins.Context.FluentBuilders.MixinConfigurationBuilder"/> object to build a new <see cref="T:Remotion.Mixins.MixinConfiguration"/> which inherits data from the
            <see cref="P:Remotion.Mixins.MixinConfiguration.ActiveConfiguration"/>. This method indirectly creates a copy of the <see cref="P:Remotion.Mixins.MixinConfiguration.ActiveConfiguration"/>. Use <see cref="M:Remotion.Mixins.MixinConfiguration.BuildNew"/> 
            to avoid the costs of copying.
            </summary>
            <returns>A <see cref="T:Remotion.Mixins.Context.FluentBuilders.MixinConfigurationBuilder"/> for building a new <see cref="T:Remotion.Mixins.MixinConfiguration"/> with a fluent interface.</returns>
            <remarks>
            <para>
            Use this method to build a new <see cref="T:Remotion.Mixins.MixinConfiguration"/> while taking over the class-mixin bindings from the
            <see cref="P:Remotion.Mixins.MixinConfiguration.ActiveConfiguration"/>.
            </para>
            <para>
            If you want to temporarily make the built
            <see cref="T:Remotion.Mixins.MixinConfiguration"/> the <see cref="P:Remotion.Mixins.MixinConfiguration.ActiveConfiguration"/>, call the builder's <see cref="M:Remotion.Mixins.Context.FluentBuilders.MixinConfigurationBuilder.EnterScope"/>
            method from within a <c>using</c> statement.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.MixinConfiguration.#ctor">
            <summary>
            Initializes an empty mixin configuration.
            </summary>
        </member>
        <member name="M:Remotion.Mixins.MixinConfiguration.#ctor(Remotion.Mixins.Context.ClassContextCollection)">
            <summary>
            Initializes a non-empty mixin configuration.
            </summary>
            <param name="classContexts">The class contexts to be held by this <see cref="T:Remotion.Mixins.MixinConfiguration"/>.</param>
        </member>
        <member name="M:Remotion.Mixins.MixinConfiguration.GetContext(System.Type)">
            <summary>
            Returns a <see cref="T:Remotion.Mixins.Context.ClassContext"/> for the given target type, or <see langword="null"/> if the type is not configured in this 
            <see cref="T:Remotion.Mixins.MixinConfiguration"/>.
            </summary>
            <param name="targetOrConcreteType">Base type for which a context should be returned or a concrete mixed type.</param>
            <returns>A <see cref="T:Remotion.Mixins.Context.ClassContext"/> for the a given target type, or <see langword="null"/> if the type is not configured.</returns>
            <exception cref="T:System.ArgumentNullException">The <paramref name="targetOrConcreteType"/> parameter is <see langword="null"/>.</exception>
            <remarks>
            <para>
            Use this to extract a class context for a given target type from an <see cref="T:Remotion.Mixins.MixinConfiguration"/> as it would be used for mixed type code 
            generation. Besides looking up the target type in the <see cref="P:Remotion.Mixins.MixinConfiguration.ClassContexts"/> collection, this method also checks whether the class
            context is empty, and returns <see langword="null"/> if so.
            </para>
            <para>
            Use the <see cref="M:Remotion.Mixins.MixinConfiguration.GetContextForce(System.Type)"/> method to reveive an empty but valid <see cref="T:Remotion.Mixins.Context.ClassContext"/> for types that do not have 
            a mixin configuration instead of <see langword="null"/>.
            </para>
            <para>
            If <paramref name="targetOrConcreteType"/> is already a generated type, the <see cref="T:Remotion.Mixins.Context.ClassContext"/> used for its generation is returned.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.MixinConfiguration.GetContextForce(System.Type)">
            <summary>
            Returns a <see cref="T:Remotion.Mixins.Context.ClassContext"/> for the given target type, generating a trivial default <see cref="T:Remotion.Mixins.Context.ClassContext"/> for types that are
            not configured in this <see cref="T:Remotion.Mixins.MixinConfiguration"/>.
            </summary>
            <param name="targetOrConcreteType">Base type for which a context should be returned or a concrete mixed type.</param>
            <returns>A <see cref="T:Remotion.Mixins.Context.ClassContext"/> for the a given target type.</returns>
            <exception cref="T:System.ArgumentNullException">The <paramref name="targetOrConcreteType"/> parameter is <see langword="null"/>.</exception>
            <remarks>
            <para>
            Use this to extract a class context for a given target type from an <see cref="T:Remotion.Mixins.MixinConfiguration"/> as it would be used to create the
            <see cref="T:Remotion.Mixins.Definitions.TargetClassDefinition"/> object for the target type. Besides looking up the target type in the given mixin configuration, this
            includes generating a default context if necessary.
            </para>
            <para>
            Use the <see cref="M:Remotion.Mixins.MixinConfiguration.GetContext(System.Type)"/> method to avoid generating an empty default <see cref="T:Remotion.Mixins.Context.ClassContext"/> for non-configured
            instances.
            </para>
            <para>
            If <paramref name="targetOrConcreteType"/> is already a generated type, a new <see cref="T:Remotion.Mixins.Context.ClassContext"/> is nevertheless generated.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.MixinConfiguration.EnterScope">
            <summary>
            Temporarily replaces the mixin configuration associated with the current thread (actually <see cref="T:Remotion.Context.SafeContext"/>) with this 
            <see cref="T:Remotion.Mixins.MixinConfiguration"/>. The original configuration will be restored when the returned object's <see cref="M:System.IDisposable.Dispose"/> 
            method is called.
            </summary>
            <returns>An <see cref="T:System.IDisposable"/> object for restoring the original configuration.</returns>
        </member>
        <member name="M:Remotion.Mixins.MixinConfiguration.Validate">
            <summary>
            Validates the whole configuration.
            </summary>
            <returns>An <see cref="T:Remotion.Mixins.Validation.ValidationLogData"/> object, which contains information about whether the configuration reresented by this context is valid.</returns>
            <remarks>This method retrieves definition items for all the <see cref="P:Remotion.Mixins.MixinConfiguration.ClassContexts"/> known by this configuration and uses the
            <see cref="T:Remotion.Mixins.Validation.Validator"/> class to validate them. The validation results can be inspected, passed to a <see cref="T:Remotion.Mixins.Validation.ValidationException"/>, or
            be dumped using the <see cref="T:Remotion.Mixins.Validation.ConsoleDumper"/>.</remarks>
            <exception cref="T:System.NotSupportedException">The <see cref="T:Remotion.Mixins.MixinConfiguration"/> contains a <see cref="T:Remotion.Mixins.Context.ClassContext"/> for a generic type, of
            which it cannot make a closed generic type. Because closed types are needed for validation, this <see cref="T:Remotion.Mixins.MixinConfiguration"/>
            cannot be validated as a whole. Even in this case, the configuration might still be correct, but validation is deferred to
            <see cref="M:Remotion.Mixins.Definitions.TargetClassDefinitionFactory.CreateTargetClassDefinition(Remotion.Mixins.Context.ClassContext)"/>.</exception>
        </member>
        <member name="M:Remotion.Mixins.MixinConfiguration.GetMasterConfiguration">
            <summary>
            Gets the master <see cref="T:Remotion.Mixins.MixinConfiguration"/>. The master configuration is the default <see cref="T:Remotion.Mixins.MixinConfiguration"/> used whenever a 
            thread first accesses its <see cref="P:Remotion.Mixins.MixinConfiguration.ActiveConfiguration"/>. If no master configuration has been set via <see cref="M:Remotion.Mixins.MixinConfiguration.SetMasterConfiguration(Remotion.Mixins.MixinConfiguration)"/>,
            a default configuration will be built by <see cref="M:Remotion.Mixins.Context.DeclarativeConfigurationBuilder.BuildDefaultConfiguration"/>.
            </summary>
            <returns>The master <see cref="T:Remotion.Mixins.MixinConfiguration"/>.</returns>
            <seealso cref="M:Remotion.Mixins.MixinConfiguration.SetMasterConfiguration(Remotion.Mixins.MixinConfiguration)"/>
        </member>
        <member name="M:Remotion.Mixins.MixinConfiguration.SetMasterConfiguration(Remotion.Mixins.MixinConfiguration)">
            <summary>
            Sets the master <see cref="T:Remotion.Mixins.MixinConfiguration"/>. The master configuration is the default <see cref="T:Remotion.Mixins.MixinConfiguration"/> used whenever a 
            thread first accesses its <see cref="P:Remotion.Mixins.MixinConfiguration.ActiveConfiguration"/>. If the master configuration is set to <see langword="null"/>, the next call
            to <see cref="M:Remotion.Mixins.MixinConfiguration.GetMasterConfiguration"/> (or the next thread first accessing its <see cref="P:Remotion.Mixins.MixinConfiguration.ActiveConfiguration"/>) will trigger a new
            default configuration to be built.
            </summary>
            <param name="newMasterConfiguration">The <see cref="T:Remotion.Mixins.MixinConfiguration"/> to be used as the new master configuration.</param>
            <remarks>
            Changes made to the master configuration will affect any thread accessing its mixin configuration for the
            first time after this method has been called.
            </remarks>
            <seealso cref="M:Remotion.Mixins.MixinConfiguration.GetMasterConfiguration"/>
        </member>
        <member name="M:Remotion.Mixins.MixinConfiguration.ResetMasterConfiguration">
            <summary>
            Causes the master mixin configuration to be rebuilt from scratch the next time a thread accesses its mixin configuration for the first time.
            </summary>
            <remarks>
            The master mixin configuration is the default mixin configuration used whenever a thread first accesses
            <see cref="P:Remotion.Mixins.MixinConfiguration.ActiveConfiguration"/>. Changes made to it will affect any thread accessing its mixin configuration for the
            first time after this method has been called.
            </remarks>
        </member>
        <member name="P:Remotion.Mixins.MixinConfiguration.HasActiveConfiguration">
            <summary>
            Gets a value indicating whether this thread has an active mixin configuration.
            </summary>
            <value>
              True if there is an active configuration for the current thread (actually <see cref="T:Remotion.Context.SafeContext"/>); otherwise, false.
            </value>
            <remarks>
            The <see cref="P:Remotion.Mixins.MixinConfiguration.ActiveConfiguration"/> property will always return a non-<see langword="null"/> configuration, no matter whether one was
            set for the current thread or not. If none was set, a default one is built using <see cref="M:Remotion.Mixins.Context.DeclarativeConfigurationBuilder.BuildDefaultConfiguration"/>.
            In order to check whether a configuration has been set (or a default one has been built), use this property.
            </remarks>
        </member>
        <member name="P:Remotion.Mixins.MixinConfiguration.ActiveConfiguration">
            <summary>
            Gets the active mixin configuration for the current thread (actually <see cref="T:Remotion.Context.SafeContext"/>).
            </summary>
            <value>The active mixin configuration for the current thread (<see cref="T:Remotion.Context.SafeContext"/>).</value>
            <remarks>
            The <see cref="P:Remotion.Mixins.MixinConfiguration.ActiveConfiguration"/> property will always return a non-<see langword="null"/> configuration, no matter whether one was
            set for the current thread or not. If none was set, a default one is built using <see cref="M:Remotion.Mixins.Context.DeclarativeConfigurationBuilder.BuildDefaultConfiguration"/>.
            In order to check whether a configuration has been set (or a default one has been built), use the <see cref="P:Remotion.Mixins.MixinConfiguration.HasActiveConfiguration"/> property.
            </remarks>
        </member>
        <member name="P:Remotion.Mixins.MixinConfiguration.ClassContexts">
            <summary>
            Gets the class contexts currently stored in this <see cref="T:Remotion.Mixins.MixinConfiguration"/>. Only contexts that have been explicitly added for classes
            are returned.
            </summary>
            <value>The class contexts currently sotred in this configuration.</value>
            <remarks>
            <para>
            Note that the collection returned cannot be used to enumerate all mixed classes, only
            those which are explicitly configured for mixins. If, for example, a base class is configured to have a mixin, its subclasses will not be
            enumerated by the collection even though they inherit the mixin from the base class.
            </para>
            <para>
            Use <see cref="M:Remotion.Mixins.MixinConfiguration.GetContext(System.Type)"/> to retrieve a <see cref="T:Remotion.Mixins.Context.ClassContext"/> for a specific type.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.MixinConfigurationScope.System#IDisposable#Dispose">
            <summary>
            When called for the first time, restores the <see cref="T:Remotion.Mixins.MixinConfiguration"/> that was the <see cref="P:Remotion.Mixins.MixinConfiguration.ActiveConfiguration"/> for the current
            thread (<see cref="T:Remotion.Context.SafeContext"/>) before this object was constructed.
            </summary>
            <remarks>
            After this method has been called for the first time, further calls have no effects. If the <see cref="M:System.IDisposable.Dispose"/> method is not called, the
            original configuration will not be restored by this object.
            </remarks>
        </member>
        <member name="T:Remotion.Mixins.MixinKind">
            <summary>
            Describes how a mixin influences its target class.
            </summary>
        </member>
        <member name="F:Remotion.Mixins.MixinKind.Extending">
            <summary>
            The mixin extends the target class from the outside, the target class might not know about being mixed. The mixin therefore has the
            possibility to override attributes (with <see cref="P:System.AttributeUsageAttribute.AllowMultiple"/> set to false) and interfaces declared
            or implemented by the target class.
            </summary>
        </member>
        <member name="F:Remotion.Mixins.MixinKind.Used">
            <summary>
            The mixin is explicitly used by the target class. The mixin therefore behaves more like a base class, eg. attributes (with 
            <see cref="P:System.AttributeUsageAttribute.AllowMultiple"/> set to false) and interfaces introduced by the mixin can be overridden by the 
            target class.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.MixinTargetMockUtility">
            <summary>
            Provides methods that support isolated testing of mixins by initializing them with mock versions of their TTarget and TNext generic parameters.
            </summary>
        </member>
        <member name="M:Remotion.Mixins.MixinTargetMockUtility.MockMixinTarget``2(Remotion.Mixins.Mixin{``0,``1},``0,``1)">
            <summary>
            Mocks the target of the given mixin instance by setting or replacing its <see cref="P:Remotion.Mixins.Mixin`1.Target"/> and
            <see cref="P:Remotion.Mixins.Mixin`2.Next"/> properties to/with the given mocks.
            </summary>
            <typeparam name="TTarget">The type of the mixin's TTarget parameter.</typeparam>
            <typeparam name="TNext">The type of the mixin's TNext parameter.</typeparam>
            <param name="mixin">The mixin whose target is to be mocked.</param>
            <param name="targetMock">The mock object to use for the mixin's <see cref="P:Remotion.Mixins.Mixin`1.Target"/> property.</param>
            <param name="nextMock">The mock object to use for the mixin's <see cref="P:Remotion.Mixins.Mixin`2.Next"/> property.</param>
            <remarks>
            <para>
            This method indirectly invokes the <see cref="M:Remotion.Mixins.Mixin`1.OnInitialized"/> method.
            </para>
            <para>
            Use this method if you already have a mixin instance. To create a new mixin with the given target mock, use the 
            <see cref="M:Remotion.Mixins.MixinTargetMockUtility.CreateMixinWithMockedTarget``3(``1,``2,System.Object[])"/> method.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.MixinTargetMockUtility.MockMixinTarget``1(Remotion.Mixins.Mixin{``0},``0)">
            <summary>
            Mocks the target of the given mixin instance by setting or replacing its <see cref="P:Remotion.Mixins.Mixin`1.Target"/> property to/with the given mocks.
            </summary>
            <typeparam name="TTarget">The type of the mixin's TTarget parameter.</typeparam>
            <param name="mixin">The mixin whose target is to be mocked.</param>
            <param name="targetMock">The mock object to use for the mixin's <see cref="P:Remotion.Mixins.Mixin`1.Target"/> property.</param>
            <remarks>
            <para>
            This method indirectly invokes the <see cref="M:Remotion.Mixins.Mixin`1.OnInitialized"/> method.
            </para>
            <para>
            Use this method if you already have a mixin instance. To create a new mixin with the given target mock, use the 
            <see cref="M:Remotion.Mixins.MixinTargetMockUtility.CreateMixinWithMockedTarget``2(``1,System.Object[])"/> method.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.MixinTargetMockUtility.CreateMixinWithMockedTarget``3(``1,``2,System.Object[])">
            <summary>
            Creates a mixin with a mocked target object.
            </summary>
            <typeparam name="TMixin">The type of mixin to create.</typeparam>
            <typeparam name="TTarget">The TTarget parameter of the mixin.</typeparam>
            <typeparam name="TNext">The TNext parameter of the mixin.</typeparam>
            <param name="targetMock">The mock object to use for the mixin's <see cref="P:Remotion.Mixins.Mixin`1.Target"/> property.</param>
            <param name="nextMock">The mock object to use for the mixin's <see cref="P:Remotion.Mixins.Mixin`2.Next"/> property.</param>
            <param name="args">The constructor arguments to be used when instantiating the mixin.</param>
            <returns>A mixin instance with the given mock objects as its <see cref="P:Remotion.Mixins.Mixin`1.Target"/> and <see cref="P:Remotion.Mixins.Mixin`2.Next"/>
            parameters.</returns>
            <remarks>
            <para>
            This method indirectly invokes the <see cref="M:Remotion.Mixins.Mixin`1.OnInitialized"/> method.
            </para>
            <para>
            This method cannot mock mixins with abstract methods, but it can mock subclasses of those mixins if they implement the abstract methods. If 
            you already have a mixin instance to be mocked, use the <see cref="M:Remotion.Mixins.MixinTargetMockUtility.MockMixinTarget``2(Remotion.Mixins.Mixin{``0,``1},``0,``1)"/> method instead.
            </para>
            <para>
            For use with Rhino Mocks, be sure to configure the current <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder"/>'s <see cref="T:Remotion.Mixins.CodeGeneration.IModuleManager"/> to
            generate transient modules instead of persistent ones (which is the default). The following example code shows how to do this:
            <code>
            ((Remotion.Mixins.CodeGeneration.DynamicProxy.ModuleManager) ConcreteTypeBuilder.Current.Scope).Scope = new ModuleScope (false);
            </code>
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.MixinTargetMockUtility.CreateMixinWithMockedTarget``2(``1,System.Object[])">
            <summary>
            Creates a mixin with a mocked target object.
            </summary>
            <typeparam name="TMixin">The type of mixin to create.</typeparam>
            <typeparam name="TTarget">The TTarget parameter of the mixin.</typeparam>
            <param name="targetMock">The mock object to use for the mixin's <see cref="P:Remotion.Mixins.Mixin`1.Target"/> property.</param>
            <param name="args">The constructor arguments to be used when instantiating the mixin.</param>
            <returns>A mixin instance with the given mock objects as its <see cref="P:Remotion.Mixins.Mixin`1.Target"/> and <see cref="P:Remotion.Mixins.Mixin`2.Next"/>
            parameters.</returns>
            <remarks>
            <para>
            This method indirectly invokes the <see cref="M:Remotion.Mixins.Mixin`1.OnInitialized"/> method.
            </para>
            <para>
            This method cannot mock mixins with abstract methods, but it can mock subclasses of those mixins if they implement the abstract methods. If 
            you already have a mixin instance to be mocked, use the <see cref="M:Remotion.Mixins.MixinTargetMockUtility.MockMixinTarget``2(Remotion.Mixins.Mixin{``0,``1},``0,``1)"/> method instead.
            </para>
            <para>
            For use with Rhino Mocks, be sure to configure the current <see cref="T:Remotion.Mixins.CodeGeneration.ConcreteTypeBuilder"/>'s <see cref="T:Remotion.Mixins.CodeGeneration.IModuleManager"/> to
            generate transient modules instead of persistent ones (which is the default). The following example code shows how to do this:
            <code>
            ((Remotion.Mixins.CodeGeneration.DynamicProxy.ModuleManager) ConcreteTypeBuilder.Current.Scope).Scope = new ModuleScope (false);
            </code>
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.MixinTargetMockUtility.MockMixinTargetAfterDeserialization``1(Remotion.Mixins.Mixin{``0},``0)">
            <summary>
            Simulates the mixin initialization occurring after deserialization, mocking its <see cref="P:Remotion.Mixins.Mixin`1.Target"/> property and invoking its
            <see cref="M:Remotion.Mixins.Mixin`1.OnDeserialized"/> method.
            </summary>
            <typeparam name="TTarget">The TTarget parameter of the mixin.</typeparam>
            <param name="mixin">The mixin to simulate deserialization with.</param>
            <param name="targetMock">The mock object to use for the mixin's <see cref="P:Remotion.Mixins.Mixin`1.Target"/> property.</param>
        </member>
        <member name="M:Remotion.Mixins.MixinTargetMockUtility.MockMixinTargetAfterDeserialization``2(Remotion.Mixins.Mixin{``0,``1},``0,``1)">
            <summary>
            Simulates the mixin initialization occurring after deserialization, mocking its <see cref="P:Remotion.Mixins.Mixin`2.Next"/> property and invoking its
            <see cref="M:Remotion.Mixins.Mixin`1.OnDeserialized"/> method.
            </summary>
            <typeparam name="TTarget">The TTarget parameter of the mixin.</typeparam>
            <typeparam name="TNext">The TNext parameter of the mixin.</typeparam>
            <param name="mixin">The mixin to simulate deserialization with.</param>
            <param name="targetMock">The mock object to use for the mixin's <see cref="P:Remotion.Mixins.Mixin`1.Target"/> property.</param>
            <param name="nextMock">The mock object to use for the mixin's <see cref="P:Remotion.Mixins.Mixin`2.Next"/> property.</param>
        </member>
        <member name="T:Remotion.Mixins.MixinTypeUtility">
            <summary>
            Provides a central point for reflectively working with mixin targets and generated concrete types.
            </summary>
        </member>
        <member name="M:Remotion.Mixins.MixinTypeUtility.IsGeneratedConcreteMixedType(System.Type)">
            <summary>
            Determines whether the given <paramref name="type"/> is a concrete, mixed type generated by the mixin infrastructure.
            </summary>
            <param name="type">The type to be checked.</param>
            <returns>
            True if <paramref name="type"/> or one of its base types was generated by the mixin infrastructure as a concrete, mixed type; otherwise, false.
            </returns>
        </member>
        <member name="M:Remotion.Mixins.MixinTypeUtility.IsGeneratedByMixinEngine(System.Type)">
            <summary>
            Determines whether the given <paramref name="type"/> was generated by the mixin infrastructure.
            </summary>
            <param name="type">The type to be checked.</param>
            <returns>
            True if <paramref name="type"/> or one of its base types was generated by the mixin infrastructure. It might be a concrete, mixed type,
            a derived mixin type, or any other type needed by the mixin infrastructure.
            </returns>
        </member>
        <member name="M:Remotion.Mixins.MixinTypeUtility.GetConcreteMixedType(System.Type)">
            <summary>
            Gets the concrete type for a given <paramref name="targetOrConcreteType"/> which contains all mixins currently configured for the type.
            </summary>
            <param name="targetOrConcreteType">The base type for which to retrieve a concrete type, or a concrete type.</param>
            <returns>The <paramref name="targetOrConcreteType"/> itself if there are no mixins configured for the type or if the type itself is a generated type;
            otherwise, a generated type containing all the mixins currently configured for <paramref name="targetOrConcreteType"/>.</returns>
        </member>
        <member name="M:Remotion.Mixins.MixinTypeUtility.GetUnderlyingTargetType(System.Type)">
            <summary>
            Gets the underlying target type for a given <paramref name="targetOrConcreteType"/>.
            </summary>
            <param name="targetOrConcreteType">The type to get the underlying target type for.</param>
            <returns>The <paramref name="targetOrConcreteType"/> itself if it is not a generated type; otherwise, the type that was used as a target type when the
            given <paramref name="targetOrConcreteType"/> was generated.</returns>
        </member>
        <member name="M:Remotion.Mixins.MixinTypeUtility.IsAssignableFrom(System.Type,System.Type)">
            <summary>
            Determines whether the given <paramref name="targetOrConcreteType"/> would be assignable to <paramref name="baseOrInterface"/> after all mixins
            currently configured for the type have been taken into account.
            </summary>
            <param name="baseOrInterface">The base or interface to assign to.</param>
            <param name="targetOrConcreteType">The type to check for assignment compatibility to <paramref name="baseOrInterface"/>. This must not be a generic
            type definition.</param>
            <returns>
            True if the type returned by <see cref="M:Remotion.Mixins.MixinTypeUtility.GetConcreteMixedType(System.Type)"/> for <paramref name="targetOrConcreteType"/> is the same as, derived from, or an
            implementation of <paramref name="baseOrInterface"/>; otherwise, false.
            </returns>
        </member>
        <member name="M:Remotion.Mixins.MixinTypeUtility.HasMixins(System.Type)">
            <summary>
            Determines whether the specified <paramref name="targetOrConcreteType"/> is associated with any mixins.
            </summary>
            <param name="targetOrConcreteType">The type to check for mixins.</param>
            <returns>
            True if the specified type is a generated type containing any mixins or a target type for which there are mixins currently configured;
            otherwise, false.
            </returns>
        </member>
        <member name="M:Remotion.Mixins.MixinTypeUtility.HasMixin(System.Type,System.Type)">
            <summary>
            Determines whether the specified <paramref name="targetOrConcreteType"/> is associated with a mixin of the given <paramref name="mixinType"/>.
            </summary>
            <param name="targetOrConcreteType">The type to check.</param>
            <param name="mixinType">The mixin type to check for.</param>
            <returns>
            True if the specified type is a generated type containing a mixin of the given <paramref name="mixinType"/> or a base type currently
            configured with such a mixin; otherwise, false.
            </returns>
            <remarks>This method checks for the exact mixin type, it does not take assignability or generic type instantiations into account. If the
            check should be broadened to include these properties, <see cref="M:Remotion.Mixins.MixinTypeUtility.GetAscribableMixinType(System.Type,System.Type)"/> should be used.</remarks>
        </member>
        <member name="M:Remotion.Mixins.MixinTypeUtility.GetAscribableMixinType(System.Type,System.Type)">
            <summary>
            Determines whether the specified <paramref name="targetOrConcreteType"/> is associated with a mixin that can be ascribed to the given
            <paramref name="mixinType"/> and returns the respective mixin type.
            </summary>
            <param name="targetOrConcreteType">The type to check.</param>
            <param name="mixinType">The mixin type to check for.</param>
            <returns>
            The exact mixin type if the specified type is a generated type containing a mixin that can be ascribed to <paramref name="mixinType"/> or a
            base type currently configured with such a mixin; otherwise <see langword="null"/>.
            </returns>
        </member>
        <member name="M:Remotion.Mixins.MixinTypeUtility.HasAscribableMixin(System.Type,System.Type)">
            <summary>
            Determines whether the specified <paramref name="targetOrConcreteType"/> is associated with a mixin that can be ascribed to the given
            <paramref name="mixinType"/>.
            </summary>
            <param name="targetOrConcreteType">The type to check.</param>
            <param name="mixinType">The mixin type to check for.</param>
            <returns>
            True, if the specified type is a generated type containing a mixin that can be ascribed to <paramref name="mixinType"/> or a
            base type currently configured with such a mixin; otherwise false.
            </returns>
        </member>
        <member name="M:Remotion.Mixins.MixinTypeUtility.GetMixinTypes(System.Type)">
            <summary>
            Gets the mixin types associated with the given <paramref name="targetOrConcreteType"/>.
            </summary>
            <param name="targetOrConcreteType">The type to check for mixin types.</param>
            <returns>The mixins included in <paramref name="targetOrConcreteType"/> if it is a generated type; otherwise the mixins currently configured for
            <paramref name="targetOrConcreteType"/>.</returns>
            <remarks>
            This method is quite fast, but it gets the mixins without ordering, and generic mixins are not closed before being returned.
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.MixinTypeUtility.GetMixinTypesExact(System.Type)">
            <summary>
            Gets the mixin types associated with the given <paramref name="targetOrConcreteType"/>, ordered and closed (if generic) exactly as they are 
            held by instances of the concrete type.
            </summary>
            <param name="targetOrConcreteType">The type to check for mixin types.</param>
            <returns>The mixins included in <paramref name="targetOrConcreteType"/> if it is a generated type; otherwise the mixins currently configured for
            <paramref name="targetOrConcreteType"/>.</returns>
            <remarks>
            This method returns the mixin types exactly as they are held in the <see cref="P:Remotion.Mixins.IMixinTarget.Mixins"/> property by the concrete type 
            corresponding to <paramref name="targetOrConcreteType"/> (or <paramref name="targetOrConcreteType"/> itself if it is a generated concrete 
            type). To retrieve them, this method might invoke the code generation for <paramref name="targetOrConcreteType"/> (if it is not already a
            concrete type). In such cases, <see cref="M:Remotion.Mixins.MixinTypeUtility.GetMixinTypes(System.Type)"/> might be the faster variant.
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.MixinTypeUtility.CreateInstance(System.Type,System.Object[])">
            <summary>
            Creates an instance of the type returned by <see cref="M:Remotion.Mixins.MixinTypeUtility.GetConcreteMixedType(System.Type)"/> for the given <paramref name="type"/>.
            </summary>
            <param name="type">The type for whose concrete type to create an instance.</param>
            <param name="args">The arguments to be passed to the constructor.</param>
            <returns>An instance of the type returned by <see cref="M:Remotion.Mixins.MixinTypeUtility.GetConcreteMixedType(System.Type)"/> for <paramref name="type"/> created via a constructor taking the
            specified <paramref name="args"/>.</returns>
        </member>
        <member name="T:Remotion.Mixins.NonIntroducedAttribute">
            <summary>
            When applied to a mixin, specifies that this mixin does not introduce a specific interface or attribute to the target class.
            </summary>
            <remarks>Use this attribute if a mixin should implement an interface or declare an attribute "just for itself" and the interface should not be
            forwarded to the target class.</remarks>
        </member>
        <member name="T:Remotion.Mixins.ObjectFactory">
            <summary>
            Provides support for instantiating type which are combined with mixins.
            </summary>
            <remarks>
            <para>
            When a target class ist combined with mixins, the target class cannot be instantiated by an ordinary constructor call. 
            Instead, a mixed type has to be created first, and this type is then instantiated.
            The <see cref="T:Remotion.Mixins.ObjectFactory"/> class provides a simple API to creating and instantiating mixed types. (To create a mixed type
            without instantiating it, use the <see cref="T:Remotion.Mixins.TypeFactory"/> class.)
            </para>
            <para>
            The <see cref="T:Remotion.Mixins.ObjectFactory"/> class uses the mixin configuration active on the current thread. Use the 
            <c>MixinConfiguration</c> class if the configuration needs to be adapted.
            </para>
            </remarks>
            <threadsafety static="true" instance="true"/>
        </member>
        <member name="M:Remotion.Mixins.ObjectFactory.Create``1">
            <summary>
            Creates a mixed instance of the given type <typeparamref name="T"/> with a public default constructor.
            </summary>
            <typeparam name="T">The target type a mixed instance of which should be created.</typeparam>
            <returns>A mixed instance of a type derived from <typeparamref name="T"/>.</returns>
            <exception cref="T:Remotion.Mixins.Validation.ValidationException">
            <para>
            The current mixin configuration for the target type violates at least one validation rule, which makes it impossible to crate
            a mixed type.
            </para>
            </exception>
            <exception cref="T:System.Exception">
            <para>
            The current mixin configuration for the target type contains severe configuration problems that make generation of a 
            target class definition object impossible.
            </para>
            <para>- or -</para>
            <para>
            The constructor of the mixed object threw an exception.
            </para>
            </exception>
            <remarks>
            <para>
            This method internally uses <see cref="M:Remotion.Mixins.TypeFactory.GetConcreteType(System.Type,Remotion.Mixins.GenerationPolicy)"/> with
            <see cref="F:Remotion.Mixins.GenerationPolicy.GenerateOnlyIfConfigured"/>. This means that mixed types are only created for
            instances which do have an active mixin configuration. All other types passed to this method are directly instantiated, without code
            generation.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.ObjectFactory.Create``1(Remotion.Reflection.ParamList,System.Object[])">
            <summary>
            Creates a mixed instance of the given type <typeparamref name="T"/> with a public constructor.
            </summary>
            <typeparam name="T">The target type a mixed instance of which should be created.</typeparam>
            <param name="constructorParameters">A <see cref="T:Remotion.Reflection.ParamList"/> object holding the parameters to be passed to the constructor.</param>
            <param name="preparedMixins">The pre-instantiated mixin instances to integrate into the mixed instance. You can specify all, none, or a subset
            of the mixins currently configured with <typeparamref name="T"/>. Those mixins for which no
            prepared instances are given will be automatically created when the mixed object is constructed.</param>
            <returns>A mixed instance of a type derived from <typeparamref name="T"/>.</returns>
            <exception cref="T:Remotion.Mixins.Validation.ValidationException">
            <para>
            The current mixin configuration for the target type violates at least one validation rule, which makes it impossible to crate
            a mixed type.
            </para>
            </exception>
            <exception cref="T:System.Exception">
            <para>
            The current mixin configuration for the target type contains severe configuration problems that make generation of a 
            target class definition object impossible.
            </para>
            <para>- or -</para>
            <para>
            The constructor of the mixed object threw an exception.
            </para>
            </exception>
            <exception cref="T:System.ArgumentException">
            <para>
            -or-
            </para>
            <para>
            The <paramref name="preparedMixins"/> parameter contains at least one mixin instance which is not
            defined as a mixin for the target type in the current thread's mixin configuration.
            </para>
            </exception>
            <remarks>
            <para>
            This method internally uses <see cref="M:Remotion.Mixins.TypeFactory.GetConcreteType(System.Type,Remotion.Mixins.GenerationPolicy)"/> with
            <see cref="F:Remotion.Mixins.GenerationPolicy.GenerateOnlyIfConfigured"/>. This means that mixed types are only created for
            instances which do have an active mixin configuration. All other types passed to this method are directly instantiated, without code
            generation.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.ObjectFactory.Create``1(Remotion.Reflection.ParamList,Remotion.Mixins.GenerationPolicy,System.Object[])">
            <summary>
            Creates a mixed instance of the given base type <typeparamref name="T"/> with a public constructor.
            </summary>
            <typeparam name="T">The target type a mixed instance of which should be created.</typeparam>
            <param name="constructorParameters">A <see cref="T:Remotion.Reflection.ParamList"/> object holding the parameters to be passed to the constructor.</param>
            <param name="generationPolicy">Indicates whether a derived class should be generated even for types that do not have an active mixin configuration.</param>
            <param name="preparedMixins">The pre-instantiated mixin instances to integrate into the mixed instance. You can specify all, none, or a subset
            of the mixins currently configured with <typeparamref name="T"/>. Those mixins for which no
            prepared instances are given will be automatically created when the mixed object is constructed.</param>
            <returns>A mixed instance of a type derived from <typeparamref name="T"/>.</returns>
            <exception cref="T:Remotion.Mixins.Validation.ValidationException">
            <para>
            The current mixin configuration for the target type violates at least one validation rule, which makes it impossible to crate
            a mixed type.
            </para>
            </exception>
            <exception cref="T:System.Exception">
            <para>
            The current mixin configuration for the target type contains severe configuration problems that make generation of a 
            target class definition object impossible.
            </para>
            <para>- or -</para>
            <para>
            The constructor of the mixed object threw an exception.
            </para>
            </exception>
            <exception cref="T:System.ArgumentException">
            <para>
            -or-
            </para>
            <para>
            The <paramref name="preparedMixins"/> parameter contains at least one mixin instance which is not
            defined as a mixin for the target type in the current thread's mixin configuration.
            </para>
            </exception>
            <remarks>
            <para>
            This method internally uses <see cref="M:Remotion.Mixins.TypeFactory.GetConcreteType(System.Type,Remotion.Mixins.GenerationPolicy)"/>. This means that mixed types might
            be created even for instances which do not have an active mixin configuration, as specified with the <paramref name="generationPolicy"/>
            parameter. In that case, all objects created via this method can be treated in the same way, but it might be inefficient to create arbitrary
            non-mixed objects with this policy.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.ObjectFactory.Create(System.Type)">
            <summary>
            Creates a mixed instance of the given <paramref name="targetOrConcreteType"/> with a public default constructor.
            </summary>
            <param name="targetOrConcreteType">The target type a mixed instance of which should be created or a concrete mixed type.</param>
            <exception cref="T:Remotion.Mixins.Validation.ValidationException">
            <para>
            The current mixin configuration for the target type violates at least one validation rule, which makes it impossible to crate
            a mixed type.
            </para>
            </exception>
            <exception cref="T:System.Exception">
            <para>
            The current mixin configuration for the target type contains severe configuration problems that make generation of a 
            target class definition object impossible.
            </para>
            <para>- or -</para>
            <para>
            The constructor of the mixed object threw an exception.
            </para>
            </exception>
            <exception cref="T:System.ArgumentNullException">The <paramref name="targetOrConcreteType"/> parameter is <see langword="null"/>.</exception>
            <exception cref="T:System.ArgumentException">
            </exception>
            <remarks>
            <para>
            This method internally uses <see cref="M:Remotion.Mixins.TypeFactory.GetConcreteType(System.Type,Remotion.Mixins.GenerationPolicy)"/> with
            <see cref="F:Remotion.Mixins.GenerationPolicy.GenerateOnlyIfConfigured"/>. This means that mixed types are only created for
            instances which do have an active mixin configuration. All other types passed to this method are directly instantiated, without code
            generation.
            </para>
            <para>
            If <paramref name="targetOrConcreteType"/> is already a generated type, this method will not subclass it again.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.ObjectFactory.Create(System.Type,Remotion.Reflection.ParamList,System.Object[])">
            <summary>
            Creates a mixed instance of the given <paramref name="targetOrConcreteType"/> with a public constructor.
            </summary>
            <param name="targetOrConcreteType">The target type a mixed instance of which should be created or a concrete mixed type.</param>
            <param name="constructorParameters">A <see cref="T:Remotion.Reflection.ParamList"/> object holding the parameters to be passed to the constructor.</param>
            <param name="preparedMixins">The pre-instantiated mixin instances to integrate into the mixed instance. You can specify all, none, or a subset
            of the mixins currently configured with <paramref name="targetOrConcreteType"/>. Those mixins for which no
            prepared instances are given will be automatically created when the mixed object is constructed.</param>
            <returns>A mixed instance of a type derived from <paramref name="targetOrConcreteType"/>.</returns>
            <exception cref="T:Remotion.Mixins.Validation.ValidationException">
            <para>
            The current mixin configuration for the target type violates at least one validation rule, which makes it impossible to crate
            a mixed type.
            </para>
            </exception>
            <exception cref="T:System.Exception">
            <para>
            The current mixin configuration for the target type contains severe configuration problems that make generation of a 
            target class definition object impossible.
            </para>
            <para>- or -</para>
            <para>
            The constructor of the mixed object threw an exception.
            </para>
            </exception>
            <exception cref="T:System.ArgumentNullException">The <paramref name="targetOrConcreteType"/> parameter is <see langword="null"/>.</exception>
            <exception cref="T:System.ArgumentException">
            <para>
            -or-
            </para>
            <para>
            The <paramref name="preparedMixins"/> parameter contains at least one mixin instance which is not
            defined as a mixin for the target type in the current thread's mixin configuration.
            </para>
            </exception>
            <remarks>
            <para>
            This method internally uses <see cref="M:Remotion.Mixins.TypeFactory.GetConcreteType(System.Type,Remotion.Mixins.GenerationPolicy)"/> with
            <see cref="F:Remotion.Mixins.GenerationPolicy.GenerateOnlyIfConfigured"/>. This means that mixed types are only created for
            instances which do have an active mixin configuration. All other types passed to this method are directly instantiated, without code
            generation.
            </para>
            <para>
            If <paramref name="targetOrConcreteType"/> is already a generated type, this method will not subclass it again.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.ObjectFactory.Create(System.Type,Remotion.Reflection.ParamList,Remotion.Mixins.GenerationPolicy,System.Object[])">
            <summary>
            Creates a mixed instance of the given <paramref name="targetOrConcreteType"/> with a public constructor.
            </summary>
            <param name="targetOrConcreteType">The target type a mixed instance of which should be created or a concrete mixed type.</param>
            <param name="constructorParameters">A <see cref="T:Remotion.Reflection.ParamList"/> object holding the parameters to be passed to the constructor.</param>
            <param name="generationPolicy">Indicates whether a derived class should be generated even for types that do not have an active mixin configuration.</param>
            <param name="preparedMixins">The pre-instantiated mixin instances to integrate into the mixed instance. You can specify all, none, or a subset
            of the mixins currently configured with <paramref name="targetOrConcreteType"/>. Those mixins for which no
            prepared instances are given will be automatically created when the mixed object is constructed.</param>
            <returns>A mixed instance of a type derived from <paramref name="targetOrConcreteType"/>.</returns>
            <exception cref="T:Remotion.Mixins.Validation.ValidationException">
            <para>
            The current mixin configuration for the target type violates at least one validation rule, which makes it impossible to crate
            a mixed type.
            </para>
            </exception>
            <exception cref="T:System.Exception">
            <para>
            The current mixin configuration for the target type contains severe configuration problems that make generation of a 
            target class definition object impossible.
            </para>
            <para>- or -</para>
            <para>
            The constructor of the mixed object threw an exception.
            </para>
            </exception>
            <exception cref="T:System.ArgumentNullException">The <paramref name="targetOrConcreteType"/> parameter is <see langword="null"/>.</exception>
            <exception cref="T:System.ArgumentException">
            <para>
            -or-
            </para>
            <para>
            The <paramref name="preparedMixins"/> parameter contains at least one mixin instance which is not
            defined as a mixin for the target type in the current thread's mixin configuration.
            </para>
            </exception>
            <remarks>
            <para>
            This method internally uses <see cref="M:Remotion.Mixins.TypeFactory.GetConcreteType(System.Type,Remotion.Mixins.GenerationPolicy)"/>. This means that mixed types might
            be created even for instances which do not have an active mixin configuration, as specified with the <paramref name="generationPolicy"/>
            parameter. In that case, all objects created via this method can be treated in the same way, but it might be inefficient to create arbitrary
            non-mixed objects with this policy.
            </para>
            <para>
            If <paramref name="targetOrConcreteType"/> is already a generated type, this method will only subclass it again when
            <see cref="F:Remotion.Mixins.GenerationPolicy.ForceGeneration"/> is specified.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.ObjectFactory.Create``1(System.Boolean,Remotion.Reflection.ParamList,System.Object[])">
            <summary>
            Creates a mixed instance of the given base type <typeparamref name="T"/>.
            </summary>
            <typeparam name="T">The target type a mixed instance of which should be created.</typeparam>
            <param name="allowNonPublicConstructors">If true, the factory will also construct objects without a public constructor. If false, an exception is thrown
            unless a public constructor is available.</param>
            <param name="constructorParameters">A <see cref="T:Remotion.Reflection.ParamList"/> object holding the parameters to be passed to the constructor.</param>
            <param name="preparedMixins">The pre-instantiated mixin instances to integrate into the mixed instance. You can specify all, none, or a subset
            of the mixins currently configured with <typeparamref name="T"/>. Those mixins for which no
            prepared instances are given will be automatically created when the mixed object is constructed.</param>
            <returns>A mixed instance of a type derived from <typeparamref name="T"/>.</returns>
            <exception cref="T:Remotion.Mixins.Validation.ValidationException">
            <para>
            The current mixin configuration for the target type violates at least one validation rule, which makes it impossible to crate
            a mixed type.
            </para>
            </exception>
            <exception cref="T:System.Exception">
            <para>
            The current mixin configuration for the target type contains severe configuration problems that make generation of a 
            target class definition object impossible.
            </para>
            <para>- or -</para>
            <para>
            The constructor of the mixed object threw an exception.
            </para>
            </exception>
            <exception cref="T:System.ArgumentException">
            <para>
            -or-
            </para>
            <para>
            The <paramref name="preparedMixins"/> parameter contains at least one mixin instance which is not
            defined as a mixin for the target type in the current thread's mixin configuration.
            </para>
            </exception>
            <remarks>
            <para>
            This method internally uses <see cref="M:Remotion.Mixins.TypeFactory.GetConcreteType(System.Type,Remotion.Mixins.GenerationPolicy)"/> with
            <see cref="F:Remotion.Mixins.GenerationPolicy.GenerateOnlyIfConfigured"/>. This means that mixed types are only created for
            instances which do have an active mixin configuration. All other types passed to this method are directly instantiated, without code
            generation.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.ObjectFactory.Create``1(System.Boolean,Remotion.Reflection.ParamList,Remotion.Mixins.GenerationPolicy,System.Object[])">
            <summary>
            Creates a mixed instance of the given base type <typeparamref name="T"/>.
            </summary>
            <typeparam name="T">The target type a mixed instance of which should be created.</typeparam>
            <param name="allowNonPublicConstructors">If true, the factory will also construct objects without a public constructor. If false, an exception is thrown
            unless a public constructor is available.</param>
            <param name="constructorParameters">A <see cref="T:Remotion.Reflection.ParamList"/> object holding the parameters to be passed to the constructor.</param>
            <param name="generationPolicy">Indicates whether a derived class should be generated even for types that do not have an active mixin configuration.</param>
            <param name="preparedMixins">The pre-instantiated mixin instances to integrate into the mixed instance. You can specify all, none, or a subset
            of the mixins currently configured with <typeparamref name="T"/>. Those mixins for which no
            prepared instances are given will be automatically created when the mixed object is constructed.</param>
            <returns>A mixed instance of a type derived from <typeparamref name="T"/>.</returns>
            <exception cref="T:Remotion.Mixins.Validation.ValidationException">
            <para>
            The current mixin configuration for the target type violates at least one validation rule, which makes it impossible to crate
            a mixed type.
            </para>
            </exception>
            <exception cref="T:System.Exception">
            <para>
            The current mixin configuration for the target type contains severe configuration problems that make generation of a 
            target class definition object impossible.
            </para>
            <para>- or -</para>
            <para>
            The constructor of the mixed object threw an exception.
            </para>
            </exception>
            <exception cref="T:System.ArgumentException">
            <para>
            -or-
            </para>
            <para>
            The <paramref name="preparedMixins"/> parameter contains at least one mixin instance which is not
            defined as a mixin for the target type in the current thread's mixin configuration.
            </para>
            </exception>
            <remarks>
            <para>
            This method internally uses <see cref="M:Remotion.Mixins.TypeFactory.GetConcreteType(System.Type,Remotion.Mixins.GenerationPolicy)"/>. This means that mixed types might
            be created even for instances which do not have an active mixin configuration, as specified with the <paramref name="generationPolicy"/>
            parameter. In that case, all objects created via this method can be treated in the same way, but it might be inefficient to create arbitrary
            non-mixed objects with this policy.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.ObjectFactory.Create(System.Boolean,System.Type,Remotion.Reflection.ParamList,System.Object[])">
            <summary>
            Creates a mixed instance of the given <paramref name="targetOrConcreteType"/>.
            </summary>
            <param name="allowNonPublicConstructors">If true, the factory will also construct objects without a public constructor. If false, an exception is thrown
            unless a public constructor is available.</param>
            <param name="targetOrConcreteType">The target type a mixed instance of which should be created or a concrete mixed type.</param>
            <param name="constructorParameters">A <see cref="T:Remotion.Reflection.ParamList"/> object holding the parameters to be passed to the constructor.</param>
            <param name="preparedMixins">The pre-instantiated mixin instances to integrate into the mixed instance. You can specify all, none, or a subset
            of the mixins currently configured with <paramref name="targetOrConcreteType"/>. Those mixins for which no
            prepared instances are given will be automatically created when the mixed object is constructed.</param>
            <returns>A mixed instance of a type derived from <paramref name="targetOrConcreteType"/>.</returns>
            <exception cref="T:Remotion.Mixins.Validation.ValidationException">
            <para>
            The current mixin configuration for the target type violates at least one validation rule, which makes it impossible to crate
            a mixed type.
            </para>
            </exception>
            <exception cref="T:System.Exception">
            <para>
            The current mixin configuration for the target type contains severe configuration problems that make generation of a 
            target class definition object impossible.
            </para>
            <para>- or -</para>
            <para>
            The constructor of the mixed object threw an exception.
            </para>
            </exception>
            <exception cref="T:System.ArgumentNullException">The <paramref name="targetOrConcreteType"/> parameter is <see langword="null"/>.</exception>
            <exception cref="T:System.ArgumentException">
            <para>
            -or-
            </para>
            <para>
            The <paramref name="preparedMixins"/> parameter contains at least one mixin instance which is not
            defined as a mixin for the target type in the current thread's mixin configuration.
            </para>
            </exception>
            <remarks>
            <para>
            This method internally uses <see cref="M:Remotion.Mixins.TypeFactory.GetConcreteType(System.Type,Remotion.Mixins.GenerationPolicy)"/> with
            <see cref="F:Remotion.Mixins.GenerationPolicy.GenerateOnlyIfConfigured"/>. This means that mixed types are only created for
            instances which do have an active mixin configuration. All other types passed to this method are directly instantiated, without code
            generation.
            </para>
            <para>
            If <paramref name="targetOrConcreteType"/> is already a generated type, this method will not subclass it again.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.ObjectFactory.Create(System.Boolean,System.Type,Remotion.Reflection.ParamList,Remotion.Mixins.GenerationPolicy,System.Object[])">
            <summary>
            Creates a mixed instance of the given <paramref name="targetOrConcreteType"/>.
            </summary>
            <param name="allowNonPublicConstructors">If true, the factory will also construct objects without a public constructor. If false, an exception is thrown
            unless a public constructor is available.</param>
            <param name="targetOrConcreteType">The target type a mixed instance of which should be created or a concrete mixed type.</param>
            <param name="constructorParameters">A <see cref="T:Remotion.Reflection.ParamList"/> object holding the parameters to be passed to the constructor.</param>
            <param name="generationPolicy">Indicates whether a derived class should be generated even for types that do not have an active mixin configuration.</param>
            <param name="preparedMixins">The pre-instantiated mixin instances to integrate into the mixed instance. You can specify all, none, or a subset
            of the mixins currently configured with <paramref name="targetOrConcreteType"/>. Those mixins for which no
            prepared instances are given will be automatically created when the mixed object is constructed.</param>
            <returns>A mixed instance of a type derived from <paramref name="targetOrConcreteType"/>.</returns>
            <exception cref="T:Remotion.Mixins.Validation.ValidationException">
            <para>
            The current mixin configuration for the target type violates at least one validation rule, which makes it impossible to crate
            a mixed type.
            </para>
            </exception>
            <exception cref="T:System.Exception">
            <para>
            The current mixin configuration for the target type contains severe configuration problems that make generation of a 
            target class definition object impossible.
            </para>
            <para>- or -</para>
            <para>
            The constructor of the mixed object threw an exception.
            </para>
            </exception>
            <exception cref="T:System.ArgumentNullException">The <paramref name="targetOrConcreteType"/> parameter is <see langword="null"/>.</exception>
            <exception cref="T:System.ArgumentException">
            <para>
            -or-
            </para>
            <para>
            The <paramref name="preparedMixins"/> parameter contains at least one mixin instance which is not
            defined as a mixin for the target type in the current thread's mixin configuration.
            </para>
            </exception>
            <remarks>
            <para>
            This method internally uses <see cref="M:Remotion.Mixins.TypeFactory.GetConcreteType(System.Type,Remotion.Mixins.GenerationPolicy)"/>. This means that mixed types might
            be created even for instances which do not have an active mixin configuration, as specified with the <paramref name="generationPolicy"/>
            parameter. In that case, all objects created via this method can be treated in the same way, but it might be inefficient to create arbitrary
            non-mixed objects with this policy.
            </para>
            <para>
            If <paramref name="targetOrConcreteType"/> is already a generated type, this method will only subclass it again when
            <see cref="F:Remotion.Mixins.GenerationPolicy.ForceGeneration"/> is specified.
            </para>
            </remarks>
        </member>
        <member name="T:Remotion.Mixins.OverrideMixinAttribute">
            <summary>
            Indicates that a target class member overrides a virtual or abstract member of one of the mixins combined with the class.
            </summary>
            <remarks>
            <para>
            An overriding member and its base member must both be public or protected, and they must have the same name and signature. If an overriding
            member would apply to multiple mixin members, this is regarded as a configuration error, unless the mixin type is explicitly specified in
            this attribute's constructor.
            </para>
            <para>
            This attribute is inherited (i.e. if the overriding member is replaced in a subclass, the subclass' member is now the overriding member) and
            can only be applied once per member.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.OverrideMixinAttribute.#ctor">
            <summary>
            Indicates that this member overrides a virtual or abstract member of one of the mixins combined with the class. The overridden member
            has the same name and signature as this member. If more than one mixin defines such a member, an exception is thrown.
            </summary>
        </member>
        <member name="M:Remotion.Mixins.OverrideMixinAttribute.#ctor(System.Type)">
            <summary>
            Indicates that this member overrides a virtual or abstract member of the given mixin type. The overridden member
            has the same name and signature as this member. If the given mixin type is not part of the current configuration, an exception is thrown.
            </summary>
            <param name="mixinType">The type (or base type or interface) of the mixin whose member to override. For generic mixins, you can specify the
            open type (with unbound generic parameters) even if the configuration contains a closed type (with bound parameters).</param>
        </member>
        <member name="T:Remotion.Mixins.OverrideTargetAttribute">
            <summary>
            Indicates that a mixin member overrides a virtual member of the mixin's target class.
            </summary>
            <remarks>
            <para>
            An overriding member and its base member must both be public or protected, and they must have the same name and signature.
            </para>
            <para>
            This attribute is inherited (i.e. if the overriding member is replaced in a subclass, the subclass' member is now the overriding member) and
            can only be applied once per member.
            </para>
            </remarks>
        </member>
        <member name="T:Remotion.Mixins.TypeExtensions">
            <summary>
            The <see cref="T:Remotion.Mixins.TypeExtensions"/> class provides extension methods for <see cref="T:System.Type"/> instances related to mixin functionality.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.TypeFactory">
            <summary>
            Provides support for combining mixins and target classes into concrete, "mixed", instantiable types.
            </summary>
            <remarks>
            <para>
            When a target class should be combined with mixins, the target class (and sometimes also the mixin types) cannot be instantiated as
            is. Instead, a concrete type has to be created which incorporates the necessary delegation code. While the type generation is actually performed
            by another class, the <see cref="T:Remotion.Mixins.TypeFactory"/> provides the public API to be used when retrieving a generated type.
            </para>
            <para>
            The <see cref="T:Remotion.Mixins.TypeFactory"/> should only be used if <see cref="T:System.Type"/> objects are required. If the combined type should be instantiated,
            the <see cref="T:Remotion.Mixins.ObjectFactory"/> class should be used instead.
            </para>
            <para>
            The <see cref="T:Remotion.Mixins.TypeFactory"/> class uses the mixin configuration active for the thread on which it is called.
            </para>
            </remarks>
            <threadsafety static="true" instance="true"/>
        </member>
        <member name="M:Remotion.Mixins.TypeFactory.GetConcreteType(System.Type)">
            <summary>
            Retrieves a concrete, instantiable, mixed type for the given <paramref name="targetOrConcreteType"/>, or <paramref name="targetOrConcreteType"/> itself if no
            mixin configuration exists for the type on the current thread.
            </summary>
            <param name="targetOrConcreteType">Base type for which a mixed type should be retrieved or a concrete mixed type.</param>
            <returns>A concrete, instantiable, mixed type for the given <paramref name="targetOrConcreteType"/>.</returns>
            <exception cref="T:System.ArgumentNullException">The <paramref name="targetOrConcreteType"/> parameter is <see langword="null"/>.</exception>
            <exception cref="T:System.Exception"><para>The current mixin configuration for the <paramref name="targetOrConcreteType"/> contains severe configuration problems 
            that make generation of a target class definition object impossible.</para><para>- or -</para><para>The current mixin configuration for 
            the <paramref name="targetOrConcreteType"/> violates at least one validation rule, which makes code generation impossible.</para> </exception>
            <remarks>
            <para>
            The type returned by this method is guaranteed to be derived from <paramref name="targetOrConcreteType"/>, but will usually not be the same as
            <paramref name="targetOrConcreteType"/>. It manages integration of the mixins with the given <paramref name="targetOrConcreteType"/>.
            </para>
            <para>
            Note that the factory will not create derived types for types not currently having a mixin configuration. This means that types returned
            by the factory can <b>not</b> always be treated as derived types. See <see cref="M:Remotion.Mixins.TypeFactory.GetConcreteType(System.Type,Remotion.Mixins.GenerationPolicy)"/> on how to
            force generation of a derived type.
            </para>
            <para>
            The returned type provides the same constructors as <paramref name="targetOrConcreteType"/> does and can thus be instantiated, e.g. via
            <see cref="M:System.Activator.CreateInstance(System.Type,System.Object[])"/>. When this happens, all the mixins associated with the generated type are also
            instantiated and configured to be used with the target instance. If you need to supply pre-created mixin instances for an object, use
            a <em>MixedObjectInstantiationScope</em>. See <see cref="T:Remotion.Mixins.ObjectFactory"/> for a simpler way to immediately create instances of mixed types.
            </para>
            <para>
            If <paramref name="targetOrConcreteType"/> is already a generated type, this method will not subclass it again.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.TypeFactory.GetConcreteType(System.Type,Remotion.Mixins.GenerationPolicy)">
            <summary>
            Retrieves a concrete, instantiable, mixed type for the given <paramref name="targetOrConcreteType"/>.
            </summary>
            <param name="targetOrConcreteType">Base type for which a mixed type should be retrieved or a concrete mixed type.</param>
            <param name="generationPolicy">Defines whether to force generation of a type even if no mixin configuration is currently available
            for the given type.</param>
            <returns>A concrete, instantiable, mixed type for the given <paramref name="targetOrConcreteType"/>, or the type itself; depending on the
            <paramref name="generationPolicy"/> and the active configuration.</returns>
            <exception cref="T:System.ArgumentNullException">The <paramref name="targetOrConcreteType"/> parameter is <see langword="null"/>.</exception>
            <exception cref="T:System.Exception"><para>The current mixin configuration for the <paramref name="targetOrConcreteType"/> contains severe configuration problems 
            that make generation of a target class definition object impossible.</para><para>- or -</para><para>The current mixin configuration for 
            the <paramref name="targetOrConcreteType"/> violates at least one validation rule, which makes code generation impossible.</para> </exception>
            <remarks>
            <para>
            The type returned by this method is guaranteed to be derived from <paramref name="targetOrConcreteType"/>, but will usually not be the same as
            <paramref name="targetOrConcreteType"/>. It manages integration of the mixins with the given <paramref name="targetOrConcreteType"/>.
            </para>
            <para>
            Note that the factory can create empty mixin configurations for types not currently having a mixin configuration, depending on the
            <paramref name="generationPolicy"/>. With <see cref="F:Remotion.Mixins.GenerationPolicy.ForceGeneration"/>, types returned by the factory can always be treated
            as derived types.
            </para>
            <para>
            The returned type provides the same constructors as <paramref name="targetOrConcreteType"/> does and can thus be instantiated, e.g. via
            <see cref="M:System.Activator.CreateInstance(System.Type,System.Object[])"/>. When this happens, all the mixins associated with the generated type are also
            instantiated and configured to be used with the target instance. If you need to supply pre-created mixin instances for an object, use
            a <em>MixedObjectInstantiationScope</em>. See <see cref="T:Remotion.Mixins.ObjectFactory"/> for a simpler way to immediately create instances of mixed types.
            </para>
            <para>
            If <paramref name="targetOrConcreteType"/> is already a generated type, this method will only subclass it again when
            <see cref="F:Remotion.Mixins.GenerationPolicy.ForceGeneration"/> is specified.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.TypeFactory.InitializeUnconstructedInstance(System.Object)">
            <summary>
            Initializes a mixin target instance which was created without its constructor having been called.
            </summary>
            <param name="mixinTarget">The mixin target to initialize.</param>
            <exception cref="T:System.ArgumentNullException">The mixin target is <see langword="null"/>.</exception>
            <remarks>This method is useful when a mixin target instance is created via <see cref="M:System.Runtime.Serialization.FormatterServices.GetSafeUninitializedObject(System.Type)"/>.</remarks>
        </member>
        <member name="T:Remotion.Mixins.UsesAttribute">
            <summary>
            Indicates that a class integrates a mixin to implement some part of its functionality or public interface.
            </summary>
            <remarks>
            <para>
            This attribute is effective for the declarative mixin configuration, which is in effect by default when an application is started.
            </para>
            <para> 
            Although the attribute itself is not inherited, its semantics in mixin configuration are: If a base class is configured to be mixed with a
            mixin type M by means of the <see cref="T:Remotion.Mixins.UsesAttribute"/>, this configuration setting is inherited by each of its (direct and indirect) subclasses.
            The subclasses will therefore also be mixed with the same mixin type M unless a second mixin M2 derived from M is applied to the subclass, thus
            overriding the inherited configuration. If M is configured for both base class and subclass, the base class configuration is ignored.
            </para>
            <para>
            This attribute can be applied to the same target class multiple times if a class depends on multiple mixins, but it should not be used to
            apply the same mixin multiple times to the same target class.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.UsesAttribute.#ctor(System.Type)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Mixins.UsesAttribute"/> class.
            </summary>
            <param name="mixinType">The mixin type the class depends on.</param>
        </member>
        <member name="P:Remotion.Mixins.UsesAttribute.MixinType">
            <summary>
            Gets the mixin type the class depends on.
            </summary>
            <value>The mixin type the class depends on.</value>
        </member>
        <member name="T:Remotion.Mixins.Utilities.CodeGenerationStatistics">
            <summary>
            Provides statistical information about the resources used by the mixin code generation engine.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.Utilities.ConstraintBasedGenericParameterInstantiator">
            <summary>
            Deduces a possible instantiation for a generic type parameter based on the constraints placed on the parameter.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.Utilities.MixedObjectInstantiationScope">
            <summary>
            Allows users to specify configuration settings when a mixed type is instantiated.
            </summary>
            <remarks>
            <para>
            Usually, the mixin types configured in the <see cref="T:Remotion.Mixins.Context.ClassContext"/> of a target class are simply instantiated when the mixed
            instance is constructed. Using this scope class, a user can supply pre-instantiated mixins instead.
            </para>
            <para>
            This is mainly for internal purposes, users should use the <see cref="T:Remotion.Mixins.ObjectFactory"/>
            class to instantiate mixed types.
            </para>
            <para>
            This class is a singleton bound to the current <see cref="T:System.Threading.Thread"/>. It does not use the <see cref="T:Remotion.Context.SafeContext"/> for performance reasons.
            </para>
            </remarks>
        </member>
        <member name="M:Remotion.Mixins.Utilities.MixedObjectInstantiationScope.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Mixins.Utilities.MixedObjectInstantiationScope"/> class, setting it as the
            <see cref="P:Remotion.Mixins.Utilities.MixedObjectInstantiationScope.Current"/> scope object. The previous scope is restored when this scope's <see cref="M:Remotion.Mixins.Utilities.MixedObjectInstantiationScope.Dispose"/>
            method is called, e.g. from a <c>using</c> statement. The new scope will not contain any pre-created mixin instances.
            </summary>
        </member>
        <member name="M:Remotion.Mixins.Utilities.MixedObjectInstantiationScope.#ctor(System.Object[])">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Mixins.Utilities.MixedObjectInstantiationScope"/> class, setting it as the
            <see cref="P:Remotion.Mixins.Utilities.MixedObjectInstantiationScope.Current"/> scope object. The previous scope is restored when this scope's <see cref="M:Remotion.Mixins.Utilities.MixedObjectInstantiationScope.Dispose"/>
            method is called, e.g. from a <c>using</c> statement. The new scope contains the specified pre-created mixin instances.
            </summary>
            <param name="suppliedMixinInstances">The mixin instances to be used when a mixed type is instantiated from within the scope. The objects
            specified must fit the mixin types specified in the mixed type's configuration. Users can also specify instances for a subset of the mixin
            types, the remaining ones will be created on demand.</param>
        </member>
        <member name="M:Remotion.Mixins.Utilities.MixedObjectInstantiationScope.Dispose">
            <summary>
            When called for the first time, restores the <see cref="T:Remotion.Mixins.Utilities.MixedObjectInstantiationScope"/> that was in effect when this scope was created.
            </summary>
        </member>
        <member name="P:Remotion.Mixins.Utilities.MixedObjectInstantiationScope.SuppliedMixinInstances">
            <summary>
            The mixin instances to be used when a mixed class is instantiated from within the scope.
            </summary>
        </member>
        <member name="M:Remotion.Mixins.Utilities.MixinReflector.GetClassContextFromConcreteType(System.Type)">
            <summary>
            Returns the <see cref="T:Remotion.Mixins.Context.ClassContext"/> that was used as the mixin configuration when the given <paramref name="concreteMixedType"/>
            was created by the <see cref="T:Remotion.Mixins.TypeFactory"/>.
            </summary>
            <param name="concreteMixedType">The type whose mixin configuration is to be retrieved.</param>
            <returns>The <see cref="T:Remotion.Mixins.Context.ClassContext"/> used when the given <paramref name="concreteMixedType"/> was created, or <see langword="null"/>
            if <paramref name="concreteMixedType"/> is no mixed type.</returns>
        </member>
        <member name="M:Remotion.Mixins.Utilities.MixinReflector.GetOrderedMixinTypesFromConcreteType(System.Type)">
            <summary>
            Returns the types of the mixins that were used to generate <paramref name="concreteMixedType"/>. The mixins are ordered and open generic 
            mixins are closed exactly as used by the code generation (and as defined by <see cref="P:Remotion.Mixins.Definitions.TargetClassDefinition.Mixins"/>.
            </summary>
            <param name="concreteMixedType">The concrete mixed type whose mixins should be retrieved.</param>
            <returns>An ordered array of mixin types that directly corresponds to the mixins held by instances of the mixed type.</returns>
        </member>
        <member name="T:Remotion.Mixins.Utilities.MixinTypeCloser">
            <summary>
            Takes a mixin type and closes it when it is a generic type definitions, inferring its generic arguments from the mixin's target type and the
            parameters' constraints.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.Utilities.Singleton.ServiceLocatorInstanceCreator`1">
            <summary>
            Implements <see cref="T:Remotion.Mixins.Utilities.Singleton.IInstanceCreator`1"/> by delegating to <see cref="T:Microsoft.Practices.ServiceLocation.ServiceLocator"/> to resolve an instance implementing
            <typeparamref name="T"/>.
            </summary>
            <typeparam name="T">The type to resolve from the <see cref="T:Microsoft.Practices.ServiceLocation.ServiceLocator"/>.</typeparam>
            <remarks>
            This class uses the <see cref="T:Remotion.ServiceLocation.SafeServiceLocator"/>, so it will use an instance of <see cref="T:Remotion.ServiceLocation.DefaultServiceLocator"/> if no other
            <see cref="T:Microsoft.Practices.ServiceLocation.IServiceLocator"/> was installed.
            </remarks>
        </member>
        <member name="T:Remotion.Mixins.Utilities.UncastableEnumerableWrapper`1">
            <summary>
            Wraps an enumerable object so that the wrapped object cannot be cast back to its original type.
            </summary>
            <typeparam name="T">The type returned by the wrapped enumerable object.</typeparam>
            <remarks>Use this class when returning an enumerable object from a method to prevent that the object can be cast to its original type.
            That way, it will be ensured that the returned object only supports the methods exposed by the <see cref="T:System.Collections.Generic.IEnumerable`1"/> interface.</remarks>
        </member>
        <member name="T:Remotion.Mixins.Validation.ValidatedDefinitionDescription">
            <summary>
            Describes a validated <see cref="T:Remotion.Mixins.Definitions.IVisitableDefinition"/> for output without actually holding on to the definition instance.
            </summary>
        </member>
        <member name="T:Remotion.Mixins.Validation.ValidationException">
            <summary>
            Thrown when there is an error in the mixin configuration which is detected during validation of the configuration. The problem prevents
            code being generated from the configuration. See also <see cref="T:Remotion.Mixins.ConfigurationException"/>.
            </summary>
        </member>
        <member name="M:Remotion.Mixins.Validation.ValidationException.#ctor(System.String,Remotion.Mixins.Validation.ValidationLogData)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Mixins.Validation.ValidationException"/> class.
            </summary>
            <param name="message">The exception message.</param>
            <param name="validationLogData">The validation log data.</param>
        </member>
        <member name="M:Remotion.Mixins.Validation.ValidationException.#ctor(Remotion.Mixins.Validation.ValidationLogData)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Mixins.Validation.ValidationException"/> class and creates a descriptive message from the validation log.
            </summary>
            <param name="validationLogData">The validation log data.</param>
            <exception cref="T:System.ArgumentNullException">The log is empty.</exception>
        </member>
        <member name="M:Remotion.Mixins.Validation.ValidationException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Initializes a new instance of the <see cref="T:Remotion.Mixins.Validation.ValidationException"/> class during deserialization.
            </summary>
            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"></see> that holds the serialized object data about the exception being thrown.</param>
            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"></see> that contains contextual information about the source or destination.</param>
            <exception cref="T:System.ArgumentNullException">The info parameter is null. </exception>
        </member>
        <member name="T:Remotion.Mixins.Validation.ValidationLogData">
            <summary>
            Holds the data written to an <see cref="T:Remotion.Mixins.Validation.IValidationLog"/>.
            </summary>
        </member>
    </members>
</doc>
